name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Order.Fin.Prod.0.Fin.prod_exists_lt_lt_of_le_of_le._simp_1_3 | Mathlib.Order.Fin.Prod | ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] {x y : α × β}, (x ≤ y) = (x.1 ≤ y.1 ∧ x.2 ≤ y.2) | null | false |
Std.DTreeMap.Const.ofList_eq_insertMany_empty | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {l : List (α × β)},
Std.DTreeMap.Const.ofList l cmp = Std.DTreeMap.Const.insertMany ∅ l | null | true |
Lean.LocalInstance.casesOn | Lean.MetavarContext | {motive : Lean.LocalInstance → Sort u} →
(t : Lean.LocalInstance) →
((className : Lean.Name) → (fvar : Lean.Expr) → motive { className := className, fvar := fvar }) → motive t | null | false |
_private.Mathlib.SetTheory.Ordinal.CantorNormalForm.0.Ordinal.CNF.rec._proof_2 | Mathlib.SetTheory.Ordinal.CantorNormalForm | ∀ (o : Ordinal.{u_1}), o = 0 → 0 = o | null | false |
Relation.reflTransGen_of_equivalence | Mathlib.Logic.Relation | ∀ {α : Type u_1} {r r' : α → α → Prop}, Equivalence r → r' ≤ r → Relation.ReflTransGen r' ≤ r | **Alias** of `Relation.reflTransGen_le_of_equivalence_of_le`. | true |
Lean.Meta.Grind.instInhabitedAction | Lean.Meta.Tactic.Grind.Types | Inhabited Lean.Meta.Grind.Action | null | true |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Basic.0.String.Slice.Pattern.Model.skipPrefixWhile_eq_iff._simp_1_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {ρ : Type} (pat : ρ) [inst : String.Slice.Pattern.Model.PatternModel pat]
[inst_1 : String.Slice.Pattern.ForwardPattern pat] [String.Slice.Pattern.Model.LawfulForwardPatternModel pat]
{s : String.Slice} (startPos endPos : s.Pos),
(startPos.skipWhile pat = endPos) =
(String.Slice.Pattern.Model.IsLongestMatch... | null | false |
_private.Mathlib.Algebra.Polynomial.RingDivision.0.Polynomial.prime_X_sub_C._simp_1_2 | Mathlib.Algebra.Polynomial.RingDivision | ∀ {R : Type u} {a : R} [inst : Semiring R] {p : Polynomial R}, p.IsRoot a = (Polynomial.eval a p = 0) | null | false |
List.findSomeRev?.eq_def | Init.Data.List.Impl | ∀ {α : Type u} {β : Type v} (f : α → Option β) (x : List α),
List.findSomeRev? f x =
match x with
| [] => none
| a :: as =>
match List.findSomeRev? f as with
| some b => some b
| none => f a | null | true |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.toLCNF.visitMData | Lean.Compiler.LCNF.ToLCNF | Lean.MData → Lean.Expr → Lean.Compiler.LCNF.ToLCNF.M✝ (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) | null | true |
_private.Mathlib.Logic.Embedding.Set.0.Function.Embedding.sigmaSet_preimage._simp_1_1 | Mathlib.Logic.Embedding.Set | ∀ {α : Type u} {a b : Set α}, (a = b) = ∀ (x : α), x ∈ a ↔ x ∈ b | null | false |
Topology.CWComplex.Subcomplex.coe_mk'' | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] [inst : T2Space X] (C : Set X) [h : Topology.CWComplex C] (E : Set X)
(I : (n : ℕ) → Set (Topology.RelCWComplex.cell C n)) [inst_1 : Topology.CWComplex E]
(union : ⋃ n, ⋃ j, Topology.RelCWComplex.openCell n ↑j = E), ↑(Topology.CWComplex.Subcomplex.mk'' C E I union) = E | null | true |
_private.Mathlib.Analysis.Convex.Combination.0.AffineIndependent.convexHull_inter._simp_1_4 | Mathlib.Analysis.Convex.Combination | ∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} [inst : AddCommMonoid M] (p : ι → Prop) [inst_1 : DecidablePred p]
(f : ι → M), (∑ a ∈ s, if p a then f a else 0) = ∑ a ∈ s with p a, f a | null | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal.0.AugmentedSimplexCategory.tensorObj.match_1.eq_1 | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀ (motive : AugmentedSimplexCategory → AugmentedSimplexCategory → Sort u_1) (m n : SimplexCategory)
(h_1 : (m n : SimplexCategory) → motive (CategoryTheory.WithInitial.of m) (CategoryTheory.WithInitial.of n))
(h_2 : (x : AugmentedSimplexCategory) → motive CategoryTheory.WithInitial.star x)
(h_3 : (x : AugmentedSi... | null | true |
Lean.StructureResolutionState.casesOn | Lean.Structure | {motive : Lean.StructureResolutionState → Sort u} →
(t : Lean.StructureResolutionState) →
((resolutions : Lean.PHashMap Lean.Name (Array Lean.Name)) → motive { resolutions := resolutions }) → motive t | null | false |
WeierstrassCurve.variableChange_j | Mathlib.AlgebraicGeometry.EllipticCurve.VariableChange | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) (C : WeierstrassCurve.VariableChange R)
[inst_1 : W.IsElliptic], (C • W).j = W.j | null | true |
Lean.Options.ctorIdx | Lean.Data.Options | Lean.Options → ℕ | null | false |
Cardinal.lift_max | Mathlib.SetTheory.Cardinal.Order | ∀ {a b : Cardinal.{v}}, Cardinal.lift.{u, v} (max a b) = max (Cardinal.lift.{u, v} a) (Cardinal.lift.{u, v} b) | null | true |
CategoryTheory.presheafHom | Mathlib.CategoryTheory.Sites.SheafHom | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{A : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} A] →
CategoryTheory.Functor Cᵒᵖ A →
CategoryTheory.Functor Cᵒᵖ A → CategoryTheory.Functor Cᵒᵖ (Type (max (max u v) v')) | Given two presheaves `F` and `G` on a category `C` with values in a category `A`,
this `presheafHom F G` is the presheaf of types which sends an object `X : C`
to the type of morphisms between the "restrictions" of `F` and `G` to the category `Over X`. | true |
QuaternionAlgebra.im_natCast | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} {c₁ c₂ c₃ : R} [inst : AddCommGroupWithOne R] (n : ℕ), (↑n).im = 0 | null | true |
Mathlib.Tactic.FinVec.vecPerm | Mathlib.Tactic.Simproc.VecPerm | Lean.Meta.Simp.Simproc | The `vecPerm` simproc computes the new entries of a vector after applying a permutation to them.
This can be used to simplify expressions as follows:
```
example {a b c : Nat} : ![a, b, c] ∘ Equiv.swap 0 1 = ![b, a, c] := by
simp [vecPerm, Equiv.swap_apply_def]
```
Note that for this simproc to work, dsimp needs to b... | true |
_private.Init.Data.UInt.Package.0.instLinearOrderPackageUInt8._proof_5 | Init.Data.UInt.Package | ∀ (a b : UInt8), a ≤ b ∨ b ≤ a | null | false |
Matroid.IsLoop.dep_of_mem._auto_1 | Mathlib.Combinatorics.Matroid.Loop | Lean.Syntax | null | false |
ModularForm.eisensteinSeriesMF._proof_2 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Basic | ∀ {k : ℤ} {N : ℕ} (a : Fin 2 → ZMod N),
∀ γ ∈ Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ) (CongruenceSubgroup.Gamma N),
SlashAction.map k γ (EisensteinSeries.eisensteinSeriesSIF a k).toFun =
(EisensteinSeries.eisensteinSeriesSIF a k).toFun | null | false |
SetLike.instSubtypeSet._proof_1 | Mathlib.Basic.SetLike.Basic | ∀ {X : Type u_1} {p : Set X → Prop}, Function.Injective Subtype.val | null | false |
MinTropical.instSemilatticeSup._proof_2 | Mathlib.Algebra.Tropical.Lattice | ∀ {R : Type u_1} [inst : SemilatticeSup R] (x x_1 : MinTropical R),
MinTropical.untrop x_1 ≤ MinTropical.untrop x ⊔ MinTropical.untrop x_1 | null | false |
Lean.Order.Array.monotone_allM | Init.Internal.Order.Lemmas | ∀ {γ : Type w} [inst : Lean.Order.PartialOrder γ] {m : Type → Type v} [inst_1 : Monad m]
[inst_2 : (α : Type) → Lean.Order.PartialOrder (m α)] [Lean.Order.MonoBind m] {α : Type u} (f : γ → α → m Bool)
(xs : Array α) (start stop : ℕ), Lean.Order.monotone f → Lean.Order.monotone fun x => Array.allM (f x) xs start sto... | null | true |
SimpleGraph.CompleteEquipartiteSubgraph.ofCopy | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | {V : Type u_1} →
{G : SimpleGraph V} →
{r t : ℕ} → (SimpleGraph.completeEquipartiteGraph r t).Copy G → G.CompleteEquipartiteSubgraph r t | A copy of a complete equipartite graph identifies a complete equipartite subgraph. | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.Order.0.Mathlib.Meta.Positivity.evalTsum._proof_1 | Mathlib.Topology.Algebra.InfiniteSum.Order | ∀ {u : Lean.Level} {α : Q(Type u)} (zα : Q(Zero «$α»)) (mα' : Q(AddCommMonoid «$α»))
(__defeqres : PLift («$zα» =Q «$mα'».toAddZeroClass.toAddZero.toZero)),
«$zα» =Q «$mα'».toAddZeroClass.toAddZero.toZero | null | false |
MulEquiv.toMagmaCatIso | Mathlib.Algebra.Category.Semigrp.Basic | {X Y : Type u} → [inst : Mul X] → [inst_1 : Mul Y] → X ≃* Y → (↧X ≅ ↧Y) | Build an isomorphism in the category `MagmaCat` from a `MulEquiv` between `Mul`s. | true |
Inclusion.IntervalDyadicReal.mem_Iic | Mathlib.Tactic.Inclusion.Extension.IntervalDyadicReal.Basic | ∀ {b x : ℝ} {I J : Inclusion.Interval Dyadic}, x ∈ I → b ∈ J → (x ∈ Set.Iic b) ∈ I.le J | null | true |
ValuativeRel.ValueGroupWithZero.lift_valuation | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : ValuativeRel R] {α : Sort u_3} (f : R → ↥(ValuativeRel.posSubmonoid R) → α)
(hf : ∀ (x y : R) (t s : ↥(ValuativeRel.posSubmonoid R)), x * ↑t ≤ᵥ y * ↑s → y * ↑s ≤ᵥ x * ↑t → f x s = f y t)
(x : R), ValuativeRel.ValueGroupWithZero.lift f hf ((ValuativeRel.valuation R) x) = f ... | null | true |
RingEquiv.toRingCatIso._proof_2 | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : Type u_1} [inst : Ring R] [inst_1 : Ring S] (e : R ≃+* S),
CategoryTheory.CategoryStruct.comp (RingCat.ofHom ↑e) (RingCat.ofHom ↑e.symm) = CategoryTheory.CategoryStruct.id ↧R | null | false |
Unitization.inl_zero | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_3} (A : Type u_4) [inst : Zero R] [inst_1 : Zero A], Unitization.inl 0 = 0 | null | true |
Std.IterStep.mapIterator | Init.Data.Iterators.Basic | {α : Type u} → {β : Type w} → {α' : Type u'} → (α → α') → Std.IterStep α β → Std.IterStep α' β | If present, applies `f` to the iterator of an `IterStep` and replaces the iterator
with the result of the application of `f`.
| true |
List.takeWhile_append_dropWhile | Init.Data.List.TakeDrop | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, List.takeWhile p l ++ List.dropWhile p l = l | null | true |
CategoryTheory.WideSubcategory | Mathlib.CategoryTheory.Widesubcategory | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(_P : CategoryTheory.MorphismProperty C) → [_P.IsMultiplicative] → Type u₁ | Structure for wide subcategories. Objects ignore the morphism property.
| true |
_private.Batteries.Data.MLList.Basic.0.MLList.uncons?Impl.match_1 | Batteries.Data.MLList.Basic | {m : Type u_1 → Type u_1} →
{α : Type u_1} →
(motive : MLList.MLListImpl✝ m α → Sort u_2) →
(x : MLList.MLListImpl✝ m α) →
(Unit → motive MLList.MLListImpl.nil✝) →
((x : α) → (xs : MLList.MLListImpl✝ m α) → motive (MLList.MLListImpl.cons✝ x xs)) →
((x : MLList.MLListImpl✝ m α) ... | null | false |
Lean.Meta.Grind.ppPattern | Lean.Meta.Tactic.Grind.EMatchTheorem | Lean.Expr → Lean.MessageData | null | true |
Monoid.PushoutI.NormalWord.rcons.eq_1 | Mathlib.GroupTheory.PushoutI | ∀ {ι : Type u_1} {G : ι → Type u_2} {H : Type u_3} [inst : (i : ι) → Group (G i)] [inst_1 : Group H]
{φ : (i : ι) → H →* G i} {d : Monoid.PushoutI.NormalWord.Transversal φ} [inst_2 : DecidableEq ι]
[inst_3 : (i : ι) → DecidableEq (G i)] (i : ι) (p : Monoid.PushoutI.NormalWord.Pair d i),
Monoid.PushoutI.NormalWord... | null | true |
Submonoid.prod_mem | Mathlib.Algebra.Group.Submonoid.BigOperators | ∀ {M : Type u_3} [inst : CommMonoid M] (S : Submonoid M) {ι : Type u_4} {t : Finset ι} {f : ι → M},
(∀ c ∈ t, f c ∈ S) → ∏ c ∈ t, f c ∈ S | Product of elements of a submonoid of a `CommMonoid` indexed by a `Finset` is in the
submonoid. | true |
Matrix.PosSemidef.diagonal | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {n : Type u_2} {R : Type u_3} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
[inst_4 : DecidableEq n] {d : n → R}, 0 ≤ d → (Matrix.diagonal d).PosSemidef | null | true |
List.map_reverse | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l : List α}, List.map f l.reverse = (List.map f l).reverse | null | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.Balanced.map.match_1_1 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} {t₁ : Std.DTreeMap.Internal.Impl α β}
(motive : (t₂ : Std.DTreeMap.Internal.Impl α β) → t₁.Balanced → t₁ = t₂ → Prop) (t₂ : Std.DTreeMap.Internal.Impl α β)
(x : t₁.Balanced) (x_1 : t₁ = t₂), (∀ (h : t₁.Balanced), motive t₁ h ⋯) → motive t₂ x x_1 | null | false |
_private.Mathlib.AlgebraicGeometry.Morphisms.Finite.0.AlgebraicGeometry.IsFinite.instHasAffinePropertyAndIsAffineFiniteCarrierObjOppositeOpensCarrierCarrierCommRingCatPresheafOpOpensTopHomAppTop._simp_1 | Mathlib.AlgebraicGeometry.Morphisms.Finite | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y),
AlgebraicGeometry.IsFinite f =
(AlgebraicGeometry.IsAffineHom f ∧
∀ (U : Y.Opens),
AlgebraicGeometry.IsAffineOpen U → (CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.Hom.app f U)).Finite) | null | false |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.evalAlts.goWithIncremental | Lean.Elab.Tactic.Induction | Lean.Meta.ElimInfo →
Array Lean.Elab.Tactic.ElimApp.Alt →
Lean.Syntax →
Option (Array Lean.Syntax) →
Lean.Syntax →
ℕ →
Array Lean.FVarId →
Array Lean.FVarId →
Array (Lean.Ident × Lean.FVarId) →
Array (Lean.Language.SnapshotBundle ... | null | true |
TopologicalSpace.Opens.coe_disjoint | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} [inst : TopologicalSpace α] {s t : TopologicalSpace.Opens α}, Disjoint ↑s ↑t ↔ Disjoint s t | null | true |
antitone_const | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {c : β}, Antitone fun x => c | null | true |
Nat.choose._f | Mathlib.Data.Nat.Choose.Basic | (x : ℕ) → Nat.below (motive := fun x => ℕ → ℕ) x → ℕ → ℕ | null | false |
Polynomial.fiberEquivQuotient._proof_5 | Mathlib.RingTheory.LocalRing.ResidueField.Polynomial | ∀ {R : Type u_1} [inst : CommRing R] (p : Ideal R) [inst_1 : p.IsPrime], IsScalarTower R p.ResidueField p.ResidueField | null | false |
Finset.prod_flip | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {M : Type u_4} [inst : CommMonoid M] {n : ℕ} (f : ℕ → M),
∏ r ∈ Finset.range (n + 1), f (n - r) = ∏ k ∈ Finset.range (n + 1), f k | null | true |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.Nat.isSemilinearSet_of_isSlice._proof_1_5 | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {ι : Type u_1} (t : Finset ι) {s : Set (ι → ℕ)} (a : ι → ℕ),
(∀ x ∈ s, ∀ i ∉ t, x i = a i) →
∀ x ∈ s,
∀ (y : ι → ℕ),
y ∈ s ↔ (y ∈ s ∧ ∀ (i : ι), x i ≤ y i) ∨ ∃ i, ∃ (_ : i ∈ t), ∃ i_1, ∃ (_ : i_1 < x i), y ∈ s ∧ y i = i_1 | null | false |
CategoryTheory.Functor.shiftMap.eq_1 | Mathlib.CategoryTheory.Shift.ShiftSequence | ∀ {C : Type u_1} {A : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} A] (F : CategoryTheory.Functor C A) {M : Type u_4} [inst_2 : AddMonoid M]
[inst_3 : CategoryTheory.HasShift C M] [inst_4 : F.ShiftSequence M] {X Y : C} {n : M}
(f : X ⟶ (CategoryTheory.shiftF... | null | true |
DirectSum.GSemiring.natCast_succ | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} {A : ι → Type u_2} {inst : AddMonoid ι} {inst_1 : (i : ι) → AddCommMonoid (A i)}
[self : DirectSum.GSemiring A] (n : ℕ),
DirectSum.GSemiring.natCast (n + 1) = DirectSum.GSemiring.natCast n + GradedMonoid.GOne.one | The canonical map from ℕ to a graded semiring respects successors. | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precomposeObjTransformObjSquare_iso_hom_app_fst_app | 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} {A₁ : Type u₄} {B₁ : Type u₅} {C₁ : Type u₆}
[inst_3 : CategoryTheor... | null | true |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.BindCasesM | Lean.Compiler.LCNF.ToLCNF | Type → Type | Auxiliary monad for implementing `bindCases` | true |
Pi.isAtom_iff | Mathlib.Order.Atoms | ∀ {ι : Type u_4} {π : ι → Type u} {f : (i : ι) → π i} [inst : (i : ι) → PartialOrder (π i)]
[inst_1 : (i : ι) → OrderBot (π i)], IsAtom f ↔ ∃ i, IsAtom (f i) ∧ ∀ (j : ι), j ≠ i → f j = ⊥ | null | true |
AlgebraicGeometry.StructureSheaf.isLocalizedModule_toPushforwardStalkAlgHom_aux | Mathlib.AlgebraicGeometry.Spec | ∀ (R S : CommRingCat) (p : PrimeSpectrum ↑R) [inst : Algebra ↑R ↑S]
(y :
↑(((TopCat.Presheaf.pushforward CommRingCat
(AlgebraicGeometry.Spec.topMap (CommRingCat.ofHom (algebraMap ↑R ↑S)))).obj
(AlgebraicGeometry.Spec.structureSheaf ↑S).obj).stalk
p)),
∃ x, x.2 • y = (Algebrai... | null | true |
UInt32.ne_of_toBitVec_ne | Init.Data.UInt.Lemmas | ∀ {a b : UInt32}, a.toBitVec ≠ b.toBitVec → a ≠ b | null | true |
HasFPowerSeriesOnBall.differentiableOn | Mathlib.Analysis.Calculus.FDeriv.Analytic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type v} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
{p : FormalMultilinearSeries 𝕜 E F} {r : ENNReal} {f : E → F} {x : E} [CompleteSpace F],
HasFPowerSeriesOnBall f ... | null | true |
CategoryTheory.Bicategory.precomp | Mathlib.CategoryTheory.Bicategory.Basic | {B : Type u} →
[inst : CategoryTheory.Bicategory B] → {a b : B} → (c : B) → (a ⟶ b) → CategoryTheory.Functor (b ⟶ c) (a ⟶ c) | Precomposition of a 1-morphism as a functor. | true |
Padic.padicNormE.image | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {q : ℚ_[p]}, q ≠ 0 → ∃ n, ‖q‖ = ↑(↑p ^ (-n)) | null | true |
TopologicalSpace.Compacts.isCompact_closure_of_mem_openRcNhds | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] {K : TopologicalSpace.Compacts α} {U : TopologicalSpace.Opens α},
U ∈ K.openRcNhds → IsCompact (closure ↑U) | null | true |
Lean.Grind.AC.Context.rec | Init.Grind.AC | {α : Sort u} →
{motive : Lean.Grind.AC.Context α → Sort u_1} →
((vars : Lean.RArray (PLift α)) → (op : α → α → α) → motive { vars := vars, op := op }) →
(t : Lean.Grind.AC.Context α) → motive t | null | false |
Mathlib.Tactic.TermCongr.mkIffForExpectedType | Mathlib.Tactic.TermCongr | Option Lean.Expr → Lean.MetaM Lean.Expr | Ensures the expected type is an iff. Returns the iff.
This expression satisfies `Lean.Expr.iff?`. | true |
SchwartzMap.ctorIdx | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | {E : Type u_5} →
{F : Type u_6} →
{inst : NormedAddCommGroup E} →
{inst_1 : NormedSpace ℝ E} → {inst_2 : NormedAddCommGroup F} → {inst_3 : NormedSpace ℝ F} → SchwartzMap E F → ℕ | null | false |
_private.Mathlib.Algebra.ContinuedFractions.TerminatedStable.0.GenContFract.contsAux.match_1.splitter | Mathlib.Algebra.ContinuedFractions.TerminatedStable | {K : Type u_1} →
(motive : Option (GenContFract.Pair K) → Sort u_2) →
(x : Option (GenContFract.Pair K)) →
(Unit → motive none) → ((gp : GenContFract.Pair K) → motive (some gp)) → motive x | null | true |
instCompleteLatticeUniformSpace._proof_6 | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type u_1} (a x x_1 : UniformSpace α), a ≤ x → a ≤ x_1 → UniformSpace.uniformity ≤ uniformity α | null | false |
Std.HashSet.filter_equiv_self_iff | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {f : α → Bool},
(Std.HashSet.filter f m).Equiv m ↔ ∀ (k : α) (h : k ∈ m), f (m.get k h) = true | null | true |
Subgroup.normalCore_le | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), H.normalCore ≤ H | null | true |
lt_of_mul_lt_mul_of_nonneg_right | Mathlib.Algebra.Order.GroupWithZero.Defs | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α] {a b c : α} [MulPosReflectLT α],
b * a < c * a → 0 ≤ a → b < c | **Alias** of `lt_of_mul_lt_mul_right`. | true |
PiTensorProduct.map₂_tprod_tprod | Mathlib.LinearAlgebra.PiTensorProduct.Basic | ∀ {ι : Type u_1} {R : Type u_4} [inst : CommSemiring R] {s : ι → Type u_7} [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] {t : ι → Type u_11} {t' : ι → Type u_12} [inst_3 : (i : ι) → AddCommMonoid (t i)]
[inst_4 : (i : ι) → Module R (t i)] [inst_5 : (i : ι) → AddCommMonoid (t' i)] [ins... | null | true |
CategoryTheory.subcanonical_typesGrothendieckTopology | Mathlib.CategoryTheory.Sites.Types | CategoryTheory.typesGrothendieckTopology.Subcanonical | null | true |
CategoryTheory.Limits.CompleteLattice.finiteLimitCone_isLimit_lift | Mathlib.CategoryTheory.Limits.Lattice | ∀ {α : Type u} {J : Type w} [inst : CategoryTheory.SmallCategory J] [inst_1 : CategoryTheory.FinCategory J]
[inst_2 : SemilatticeInf α] [inst_3 : OrderTop α] (F : CategoryTheory.Functor J α) (s : CategoryTheory.Limits.Cone F),
(CategoryTheory.Limits.CompleteLattice.finiteLimitCone F).isLimit.lift s = CategoryTheory... | null | true |
CauSeq.coe_smul._simp_1 | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α]
[inst_3 : Ring β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] {G : Type u_3} [inst_5 : SMul G β]
[inst_6 : IsScalarTower G β β] (a : G) (f : CauSeq β abv), a • ↑f = ↑(a • f) | null | false |
StrongDual.extendRCLikeₗ._proof_7 | Mathlib.Analysis.RCLike.Extend | ContinuousConstSMul ℝ ℝ | null | false |
CategoryTheory.Limits.Cowedge.ext._auto_1 | Mathlib.CategoryTheory.Limits.Shapes.End | Lean.Syntax | null | false |
TensorProduct.directSum._proof_11 | Mathlib.LinearAlgebra.DirectSum.TensorProduct | ∀ (R : Type u_6) [inst : CommSemiring R] (S : Type u_5) [inst_1 : Semiring S] [inst_2 : Algebra R S] {ι₁ : Type u_1}
{ι₂ : Type u_3} [inst_3 : DecidableEq ι₁] [inst_4 : DecidableEq ι₂] (M₁ : ι₁ → Type u_2) (M₂ : ι₂ → Type u_4)
[inst_5 : (i₁ : ι₁) → AddCommMonoid (M₁ i₁)] [inst_6 : (i₂ : ι₂) → AddCommMonoid (M₂ i₂)]... | null | false |
Fin.succAbove_ne_zero_zero | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} [inst : NeZero n] {a : Fin (n + 1)}, a ≠ 0 → a.succAbove 0 = 0 | null | true |
CategoryTheory.Limits.biconeIsBilimitOfColimitCoconeOfIsColimit._proof_1 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Preadditive C] {J : Type u_1}
{f : J → C} {t : CategoryTheory.Limits.Cocone (CategoryTheory.Discrete.functor f)}
(ht : CategoryTheory.Limits.IsColimit t) (j : CategoryTheory.Discrete J),
CategoryTheory.CategoryStruct.comp (t.ι... | null | false |
Std.Iter.Total.ctorIdx | Init.Data.Iterators.Consumers.Total | {α β : Type w} → Std.Iter.Total β → ℕ | null | false |
SubringClass.toNonAssocRing | Mathlib.Algebra.Ring.Subring.Defs | {R : Type u} →
{S : Type v} → [inst : NonAssocRing R] → [inst_1 : SetLike S R] → [hSR : SubringClass S R] → (s : S) → NonAssocRing ↥s | A subring of a non-unital ring inherits a non-unital ring structure | true |
ModelPi | Mathlib.Geometry.Manifold.ChartedSpace | {ι : Type u_4} → (ι → Type u_5) → Type (max u_4 u_5) | Same thing as `∀ i, H i`. We introduce it for technical reasons,
see note [Manifold type tags]. | true |
CategoryTheory.Square.commSq | Mathlib.CategoryTheory.Square | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C),
CategoryTheory.CommSq sq.f₁₂ sq.f₁₃ sq.f₂₄ sq.f₃₄ | null | true |
LieSubalgebra.coe_sInf | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(S : Set (LieSubalgebra R L)), ↑(sInf S) = ⋂ s ∈ S, ↑s | null | true |
_private.Mathlib.Tactic.TermCongr.0.Mathlib.Tactic.TermCongr.CongrResult.mk'.toEqPf | Mathlib.Tactic.TermCongr | Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | Given a `pf` of an `Iff`, `Eq`, or `HEq`, return a proof of `Eq`.
If `pf` is not obviously any of these, weakly try inserting `propext` to make an `Iff`
and otherwise unify the type with `Eq`. | true |
Aesop.ForwardHypData.noConfusion | Aesop.RuleTac.Forward.Basic | {P : Sort u} → {t t' : Aesop.ForwardHypData} → t = t' → Aesop.ForwardHypData.noConfusionType P t t' | null | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape.0.CategoryTheory.TransfiniteCompositionOfShape.map._simp_3 | Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | null | false |
CommSemiRingCat.commSemiringObj._proof_17 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J CommSemiRingCat) (j : J)
(a b c : (F.comp (CategoryTheory.forget CommSemiRingCat)).obj j), a * b * c = a * (b * c) | null | false |
_private.Lean.Compiler.LCNF.Level.0.Lean.Compiler.LCNF.NormLevelParam.normLevel.match_1 | Lean.Compiler.LCNF.Level | (motive : Lean.Compiler.LCNF.NormLevelParam.State → Sort u_1) →
(x : Lean.Compiler.LCNF.NormLevelParam.State) →
((nextIdx : ℕ) →
(map : Std.HashMap Lean.Name Lean.Level) →
(paramNames : Array Lean.Name) → motive { nextIdx := nextIdx, map := map, paramNames := paramNames }) →
motive x | null | false |
_aux_Mathlib_Basic_Real_Basic___macroRules_termℝ_1 | Mathlib.Basic.Real.Basic | Lean.Macro | null | false |
Lean.Lsp.SignatureHelpTriggerKind.contentChange.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SignatureHelpTriggerKind → Sort u} →
(t : Lean.Lsp.SignatureHelpTriggerKind) →
t.ctorIdx = 2 → motive Lean.Lsp.SignatureHelpTriggerKind.contentChange → motive t | null | false |
_private.Lean.Meta.Sym.Simp.Theorems.0.Lean.Meta.Sym.Simp.isPerm.match_1 | Lean.Meta.Sym.Simp.Theorems | (motive : Except Unit (Unit × Array (Option ℕ)) → Sort u_1) →
(x : Except Unit (Unit × Array (Option ℕ))) →
((a : Unit × Array (Option ℕ)) → motive (Except.ok a)) →
((x : Except Unit (Unit × Array (Option ℕ))) → motive x) → motive x | null | false |
Matrix.linearIndependent_rows_of_invertible | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {m : Type u} [inst : DecidableEq m] [inst_1 : Fintype m] {R : Type u_4} [inst_2 : Ring R] [IsArtinianRing R]
(A : Matrix m m R) [Invertible A], LinearIndependent R A.row | **Alias** of `Matrix.linearIndependent_row_of_invertible`. | true |
SSetPair.instPreservesColimitChainComplexNatWalkingParallelPairParallelPairChainComplexMapHomSSetOfNatHomChainComplexObjIdLeftRightEvalDown | Mathlib.AlgebraicTopology.SimplicialSet.Homology.Relative | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasCoproducts C]
[inst_2 : CategoryTheory.Preadditive C] (R : C) (P : SSetPair) (n : ℕ),
CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair (SSet.chainComplexMap P.hom R) 0)
(HomologicalComplex... | null | true |
Nat.bit_lt_bit | Mathlib.Data.Nat.Bits | ∀ {m n : ℕ} (a b : Bool), m < n → Nat.bit a m < Nat.bit b n | null | true |
CategoryTheory.SimplicialThickening.Path.rec | Mathlib.AlgebraicTopology.SimplicialNerve | {J : Type u_1} →
[inst : LinearOrder J] →
{i j : J} →
{motive : CategoryTheory.SimplicialThickening.Path i j → Sort u} →
((I : Set J) →
(left : i ∈ I) →
(right : j ∈ I) →
(left_le : ∀ k ∈ I, i ≤ k) →
(le_right : ∀ k ∈ I, k ≤ j) →
... | null | false |
Lean.Compiler.LCNF.FixedParams.Context.recOn | Lean.Compiler.LCNF.FixedParams | {motive : Lean.Compiler.LCNF.FixedParams.Context → Sort u} →
(t : Lean.Compiler.LCNF.FixedParams.Context) →
((decls : Array (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)) →
(main : Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure) →
(assignment : Lean.FVarIdMap Lean.Compiler.LCN... | null | false |
CategoryTheory.Functor.preservesLimit_cospan_of_mem_presieve | Mathlib.CategoryTheory.Sites.Precoverage | ∀ {C : Type u_1} {D : Type u_2} {inst : CategoryTheory.Category.{v_1, u_1} C}
{inst_1 : CategoryTheory.Category.{v_2, u_2} D} {F : CategoryTheory.Functor C D} {X : C}
(R : CategoryTheory.Presieve X) [self : F.PreservesPairwisePullbacks R] ⦃Y Z : C⦄ ⦃f : Y ⟶ X⦄ ⦃g : Z ⟶ X⦄,
R f → R g → CategoryTheory.Limits.Preser... | **Alias** of `CategoryTheory.Functor.PreservesPairwisePullbacks.preservesLimit`. | true |
MonomialOrder.lex._proof_3 | Mathlib.Data.Finsupp.MonomialOrder | ∀ {σ : Type u_1} (a b : σ →₀ ℕ), toLex (a + b) = toLex a + toLex b | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.