name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Tactic.ComputeAsymptotics.UnitMonomial.AllZero.eq_1 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Predicates | ∀ (m : Tactic.ComputeAsymptotics.UnitMonomial), m.AllZero = (m.sign = Tactic.ComputeAsymptotics.UnitMonomial.Sign.zero) | null | true |
Matrix.kroneckerTMulStarAlgEquiv_symm_apply | Mathlib.RingTheory.MatrixAlgebra | ∀ {m : Type u_2} {n : Type u_3} (R : Type u_5) (S : Type u_6) {A : Type u_7} {B : Type u_8} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Fintype n]
[inst_6 : DecidableEq n] [inst_7 : CommSemiring S] [inst_8 : Algebra R S] [inst_9 : Algeb... | null | true |
FirstOrder.Language.PartialEquiv.toEmbeddingOfEqTop | Mathlib.ModelTheory.PartialEquiv | {L : FirstOrder.Language} →
{M : Type w} →
{N : Type w'} →
[inst : L.Structure M] → [inst_1 : L.Structure N] → {f : L.PartialEquiv M N} → f.dom = ⊤ → L.Embedding M N | Given a partial equivalence which has the whole structure as domain,
returns the corresponding embedding. | true |
_private.Mathlib.Analysis.SpecialFunctions.Log.RpowTendsto.0.Real.tendstoLocallyUniformlyOn_rpow_sub_one_log._proof_1_12 | Mathlib.Analysis.SpecialFunctions.Log.RpowTendsto | ∀ (p : ℝ), 0 < p → 0 ≤ p⁻¹ | null | false |
Function.Periodic.eq_1 | Mathlib.Algebra.Ring.Periodic | ∀ {α : Type u_1} {β : Type u_2} [inst : Add α] (f : α → β) (c : α), Function.Periodic f c = ∀ (x : α), f (x + c) = f x | null | true |
AddMonoidHom.codRestrict | Mathlib.Algebra.Group.Submonoid.Operations | {M : Type u_1} →
{N : Type u_2} →
[inst : AddZeroClass M] →
[inst_1 : AddZeroClass N] →
{S : Type u_5} →
[inst_2 : SetLike S N] →
[inst_3 : AddSubmonoidClass S N] → (f : M →+ N) → (s : S) → (∀ (x : M), f x ∈ s) → M →+ ↥s | Restriction of an `AddMonoidHom` to an `AddSubmonoid` of the codomain. | true |
_private.Init.Data.Array.Extract.0.Array.extract_size_left._proof_1_1 | Init.Data.Array.Extract | ∀ {α : Type u_1} {j : ℕ} {as : Array α}, ¬min j as.size ≤ as.size → False | null | false |
quotAdjoinEquivQuotMap._proof_2 | Mathlib.RingTheory.Conductor | ∀ {R : Type u_2} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S], RingHomClass (R →+* S) R S | null | false |
CategoryTheory.functorProdFunctorEquivUnitIso | Mathlib.CategoryTheory.Products.Basic | (A : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
(B : Type u₂) →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
(C : Type u₃) →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
CategoryTheory.Functor.id (CategoryTheory.Functor A B × CategoryTheory.Functor A C) ≅
... | The unit isomorphism for `functorProdFunctorEquiv` | true |
_private.Mathlib.NumberTheory.Ostrowski.0.Rat.AbsoluteValue.equiv_padic_of_bounded._simp_1_6 | Mathlib.NumberTheory.Ostrowski | ∀ {x : ℝ}, 0 ≤ x → ∀ (y z : ℝ), (x ^ y) ^ z = x ^ (y * z) | null | false |
CategoryTheory.instDecidableEqPairwise.decEq._proof_2 | Mathlib.CategoryTheory.Category.Pairwise | ∀ {ι : Type u_1} (a a_1 : ι), CategoryTheory.Pairwise.pair a a_1 = CategoryTheory.Pairwise.pair a a_1 | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0._regBuiltin.UInt64.reduceAdd.declare_251._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.869070958._hygCtx._hyg.42 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
Int.getD_toList_roo_eq_fallback | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n fallback : ℤ} {i : ℕ}, (n - (m + 1)).toNat ≤ i → (m<...n).toList.getD i fallback = fallback | null | true |
Nat.instMonoidWithZero | Mathlib.Algebra.GroupWithZero.Nat | MonoidWithZero ℕ | null | true |
Array.any_flatten' | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {stop : ℕ} {f : α → Bool} {xss : Array (Array α)},
stop = xss.flatten.size → xss.flatten.any f 0 stop = xss.any fun x => x.any f | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform.0.CategoryTheory.Limits.CatCospanTransform.instIsIsoWhiskerRight._simp_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {A' : Type u₄} {B' : Type u₅} {C' : Type u₆} {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 : Categ... | null | false |
CategoryTheory.MonoOver.imageMonoOver | Mathlib.CategoryTheory.Subobject.MonoOver | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y : C} → (f : X ⟶ Y) → [CategoryTheory.Limits.HasImage f] → CategoryTheory.MonoOver Y | The `MonoOver Y` for the image inclusion for a morphism `f : X ⟶ Y`.
| true |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.CacheKey.mk.injEq | Lean.Compiler.LCNF.ToLCNF | ∀ (expr : Lean.Expr) (expectedType? : Option Lean.Expr) (ignoreNoncomputable : Bool) (expr_1 : Lean.Expr)
(expectedType?_1 : Option Lean.Expr) (ignoreNoncomputable_1 : Bool),
({ expr := expr, expectedType? := expectedType?, ignoreNoncomputable := ignoreNoncomputable } =
{ expr := expr_1, expectedType? := expe... | null | true |
fintypeAffineCoords.eq_1 | Mathlib.LinearAlgebra.AffineSpace.Basis | ∀ (ι : Type u_1) (k : Type u_2) [inst : Ring k] [inst_1 : Fintype ι],
fintypeAffineCoords ι k = AffineSubspace.comap (Fintype.linearCombination k 1).toAffineMap (affineSpan k {1}) | null | true |
Lean.PrettyPrinter.Delaborator.delabNeg | Lean.PrettyPrinter.Delaborator.Builtins | Lean.PrettyPrinter.Delaborator.Delab | Delaborates the negative of an `OfNat.ofNat` literal.
`-@OfNat.ofNat _ n _` ~> `-n`
| true |
Filter.Tendsto.inseparable_iff_uniformity | Mathlib.Topology.UniformSpace.Separation | ∀ {α : Type u} [inst : UniformSpace α] {β : Type u_1} {l : Filter β} [l.NeBot] {f g : β → α} {a b : α},
Filter.Tendsto f l (nhds a) →
Filter.Tendsto g l (nhds b) → (Inseparable a b ↔ Filter.Tendsto (fun x => (f x, g x)) l (uniformity α)) | null | true |
_private.Mathlib.Topology.Algebra.AsymptoticCone.0.zero_mem_asymptoticCone._simp_1_1 | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {α : Type u} {s : Set α}, (¬s.Nonempty) = (s = ∅) | null | false |
CategoryTheory.Functor.structuredArrowMapCone._proof_1 | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_3} {D : Type u_4} {H : Type u_6} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] [inst_2 : CategoryTheory.Category.{u_5, u_6} H]
(L : CategoryTheory.Functor C D) (F : CategoryTheory.Functor C H) (G : CategoryTheory.Functor D H) (α : L.comp G ⟶ F)
(Y : D)... | null | false |
MeasureTheory.tsum_meas_le_meas_iUnion_of_disjoint | Mathlib.MeasureTheory.Measure.Basic | ∀ {α : Type u_1} {ι : Type u_3} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) {As : ι → Set α},
(∀ (i : ι), MeasurableSet (As i)) → Pairwise (Function.onFun Disjoint As) → ∑' (i : ι), μ (As i) ≤ μ (⋃ i, As i) | The measure of a disjoint union (even uncountable) of measurable sets is at least the sum of
the measures of the sets. | true |
SubMulAction.ofStabilizer.conjMap._proof_4 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | ∀ {G : Type u_2} [inst : Group G] {α : Type u_1} [inst_1 : MulAction G α] {g : G} {a b : α},
b = g • a → ∀ (x : ↥(MulAction.stabilizer G a)) (x_1 : ↥(SubMulAction.ofStabilizer G a)), g • ↑(x • x_1) ∈ {b} → False | null | false |
RegularExpression.matches'.eq_def | Mathlib.Computability.RegularExpressions | ∀ {α : Type u_1} (x : RegularExpression α),
x.matches' =
match x with
| RegularExpression.zero => 0
| RegularExpression.epsilon => 1
| RegularExpression.char a => {[a]}
| P.plus Q => P.matches' + Q.matches'
| P.comp Q => P.matches' * Q.matches'
| P.star => KStar.kstar P.matches' | null | true |
_private.Init.Data.Array.Lemmas.0.Array.all_toList._simp_1_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {a : α} {l : List α}, (a ∈ l) = ∃ i, ∃ (h : i < l.length), l[i] = a | null | false |
Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticStop__1 | Init.Tactics | Lean.Macro | `stop` is a helper tactic for "discarding" the rest of a proof:
it is defined as `repeat sorry`.
It is useful when working on the middle of a complex proofs,
and less messy than commenting the remainder of the proof.
| false |
Finset.eventually_cocardinal_notMem | Mathlib.Order.Filter.Cocardinal | ∀ {α : Type u} {c : Cardinal.{u}} {hreg : c.IsRegular} (s : Finset α), ∀ᶠ (x : α) in Filter.cocardinal α hreg, x ∉ s | null | true |
star_mul_self_nonneg._simp_1 | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
(r : R), (0 ≤ star r * r) = True | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.Zarankiewicz.0.SimpleGraph.zarankiewicz_le_iff.match_1_4 | Mathlib.Combinatorics.SimpleGraph.Extremal.Zarankiewicz | ∀ {V : Type u_1} {W : Type u_2} {α : Type u_3} {β : Type u_4} (x : SimpleGraph (V ⊕ W))
(motive : x ≤ completeBipartiteGraph V W ∧ (completeBipartiteGraph α β).Free x → Prop)
(x_1 : x ≤ completeBipartiteGraph V W ∧ (completeBipartiteGraph α β).Free x),
(∀ (h_le : x ≤ completeBipartiteGraph V W) (h_free : (complet... | null | false |
Multiset.dedup_cons_of_mem | Mathlib.Data.Multiset.Dedup | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, a ∈ s → (a ::ₘ s).dedup = s.dedup | null | true |
String.Pos.find? | Init.Data.String.Search | {ρ : Type} →
{σ : String.Slice → Type} →
[inst : (s : String.Slice) → Std.Iterator (σ s) Id (String.Slice.Pattern.SearchStep s)] →
[(s : String.Slice) → Std.IteratorLoop (σ s) Id Id] →
{s : String} → s.Pos → (pattern : ρ) → [String.Slice.Pattern.ToForwardSearcher pattern σ] → Option s.Pos | Finds the position of the first match of the pattern `pattern` in after the position
`pos`. If there is no match `none` is returned.
This function is generic over all currently supported patterns.
Examples:
* `("coffee tea water".startPos.find? Char.isWhitespace).map (·.get!) == some ' '`
* `("tea".pos ⟨1⟩ (by deci... | true |
CategoryTheory.yonedaCommRing._proof_8 | Mathlib.CategoryTheory.Monoidal.Cartesian.Ring | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {X Y Z : CategoryTheory.CommRingObjCat C} (f : X ⟶ Y) (g : Y ⟶ Z),
{
app := fun X_1 =>
CommRingCat.ofHom
{ toFun := fun x => Catego... | null | false |
CategoryTheory.ShortComplex.isLimitOfIsLimitπ | Mathlib.Algebra.Homology.ShortComplex.Limits | {J : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
{F : CategoryTheory.Functor J (CategoryTheory.ShortComplex C)} →
(c : CategoryTheory.Limits.... | If a cone with values in `ShortComplex C` is such that it becomes limit
when we apply the three projections `ShortComplex C ⥤ C`, then it is limit. | true |
Set.biInter_finsetSigma_univ' | Mathlib.Data.Fintype.Sigma | ∀ {ι : Type u_1} {α : Type u_2} {κ : ι → Type u_3} [inst : (i : ι) → Fintype (κ i)] (s : Finset ι)
(f : (i : ι) → κ i → Set α), ⋂ i ∈ s, ⋂ j, f i j = ⋂ ij ∈ s.sigma fun x => Finset.univ, f ij.fst ij.snd | null | true |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.encodeExprWithEta.go._unsafe_rec | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | Array (Array Lean.Meta.RefinedDiscrTree.Key × Lean.Meta.RefinedDiscrTree.LazyEntry) →
Array (Array Lean.Meta.RefinedDiscrTree.Key) → Lean.MetaM (Array (Array Lean.Meta.RefinedDiscrTree.Key)) | null | false |
QuadraticModuleCat.instMonoidalCategoryStruct._proof_1 | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat.Monoidal | ∀ {R : Type u_1} [inst : CommRing R], SMulCommClass R R R | null | false |
LinearPMap.sSup | Mathlib.LinearAlgebra.LinearPMap | {R : Type u_1} →
{S : Type u_2} →
[inst : Ring R] →
[inst_1 : Ring S] →
{σ : R →+* S} →
{E : Type u_4} →
[inst_2 : AddCommGroup E] →
[inst_3 : Module R E] →
{F : Type u_5} →
[inst_4 : AddCommGroup F] →
[inst_5 ... | For a family of (semi)linear maps with a directed domains such that the one defined on a larger
domain restricts to the one defined on the smaller domain, this defines the (semi)linear map defined
on the union of the domains extending all the (semi)linear maps in the family. | true |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.bindCases | Lean.Compiler.LCNF.ToLCNF | Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure →
Lean.Compiler.LCNF.Cases Lean.Compiler.LCNF.Purity.pure →
Lean.Compiler.LCNF.CompilerM (Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) | This method returns code that at each exit point of `cases`, it jumps to `jpDecl`.
It is similar to `Code.bind`, but we add special support for `inlineMatcher`.
The `inlineMatcher` function inlines the auxiliary `_match_<idx>` declarations.
To make sure there is no code duplication, `inlineMatcher` creates auxiliary de... | true |
AddOpposite.one_le_op._simp_1 | Mathlib.Algebra.Order.Group.Opposite | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : PartialOrder α] {a : α}, (1 ≤ AddOpposite.op a) = (1 ≤ a) | null | false |
CategoryTheory.linearYoneda_map_app | Mathlib.CategoryTheory.Linear.Yoneda | ∀ (R : Type w) [inst : Ring R] (C : Type u) [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {X₁ X₂ : C} (f : X₁ ⟶ X₂) (Y : Cᵒᵖ),
((CategoryTheory.linearYoneda R C).map f).app Y =
ModuleCat.ofHom (CategoryTheory.Linear.rightComp R (Opposite... | null | true |
CommSemiRingCat.instConcreteCategoryRingHomCarrier | Mathlib.Algebra.Category.Ring.Basic | CategoryTheory.ConcreteCategory CommSemiRingCat fun R S => ↑R →+* ↑S | null | true |
Std.DTreeMap.Internal.Impl.getKeyLT._f | Std.Data.DTreeMap.Internal.Queries | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
[Std.TransOrd α] →
(k : α) →
(x : Std.DTreeMap.Internal.Impl α β) →
Std.DTreeMap.Internal.Impl.below (motive := fun x => x.Ordered → (∃ a ∈ x, compare a k = Ordering.lt) → α)
x →
x.Ordered → (∃ a ∈... | null | false |
Pi.instPNatPowAssoc | Mathlib.Algebra.Group.PNatPowAssoc | ∀ {ι : Type u_2} {α : ι → Type u_3} [inst : (i : ι) → Mul (α i)] [inst_1 : (i : ι) → Pow (α i) ℕ+]
[∀ (i : ι), PNatPowAssoc (α i)], PNatPowAssoc ((i : ι) → α i) | null | true |
AddGrpCat.addGroupObj._aux_1 | Mathlib.Algebra.Category.Grp.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_2, u_3} J] →
(F : CategoryTheory.Functor J AddGrpCat) → (j : J) → Zero ((F.comp (CategoryTheory.forget AddGrpCat)).obj j) | null | false |
Lean.KeyedDeclsAttribute.noConfusionType | Lean.KeyedDeclsAttribute | Sort u → {γ : Type} → Lean.KeyedDeclsAttribute γ → {γ' : Type} → Lean.KeyedDeclsAttribute γ' → Sort u | null | false |
Lean.Elab.Do.elabNestedAction | Lean.Elab.Do.Basic | Lean.Elab.Term.TermElab | null | true |
WType.Listα.cons | Mathlib.Data.W.Constructions | {γ : Type u} → γ → WType.Listα γ | null | true |
_private.Lean.Meta.Tactic.SplitIf.0.Lean.Meta.initFn._@.Lean.Meta.Tactic.SplitIf.3526097586._hygCtx._hyg.2 | Lean.Meta.Tactic.SplitIf | IO Unit | null | false |
Turing.ToPartrec.Code.zero_eval | Mathlib.Computability.TuringMachine.Config | ∀ (v : List ℕ), Turing.ToPartrec.Code.zero.eval v = pure [0] | null | true |
Mathlib.Tactic.BicategoryLike.State.mk._flat_ctor | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Lean.PersistentExprMap Mathlib.Tactic.BicategoryLike.Mor₁ → Mathlib.Tactic.BicategoryLike.State | null | false |
Subgroup.zpow._proof_1 | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) (a : ↥H) (n : ℤ), ↑a ^ n ∈ H | null | false |
instBooleanAlgebraAsBoolAlg._proof_9 | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanRing α] (a b : AsBoolAlg α), Mul.mul a b ≤ b | null | false |
Std.ExtDHashMap.Const.getKey?_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtDHashMap α fun x => Unit} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {l : List α} {k k' : α},
(k == k') = true →
k ∉ m →
List.Pairwise (fun a b => (a == b) = false) l →
k ∈ l → (Std.ExtDHashMap.Const.insertManyIfNewUnit m l).getKey? k'... | null | true |
WithTop.coe_covBy_top._simp_2 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, (↑a ⋖ ⊤) = IsMax a | null | false |
Matrix.PosSemidef.kronecker | Mathlib.Analysis.Matrix.Order | ∀ {𝕜 : Type u_1} {n : Type u_2} [inst : RCLike 𝕜] [Finite n] {m : Type u_3} [Finite m] {x : Matrix n n 𝕜}
{y : Matrix m m 𝕜}, x.PosSemidef → y.PosSemidef → (Matrix.kroneckerMap (fun x1 x2 => x1 * x2) x y).PosSemidef | The kronecker product of two positive semi-definite matrices is positive semi-definite. | true |
_private.Mathlib.Data.Nat.Factorial.DoubleFactorial.0.Nat.doubleFactorial.match_1.eq_2 | Mathlib.Data.Nat.Factorial.DoubleFactorial | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1) (h_3 : (k : ℕ) → motive k.succ.succ),
(match 1 with
| 0 => h_1 ()
| 1 => h_2 ()
| k.succ.succ => h_3 k) =
h_2 () | null | true |
Sym2.coe_map | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (z : Sym2 α), ↑(Sym2.map f z) = f '' ↑z | null | true |
_private.Mathlib.CategoryTheory.Limits.Preserves.Shapes.Zero.0.CategoryTheory.Functor.map_isZero._simp_1_1 | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (X : C),
CategoryTheory.Limits.IsZero X = (CategoryTheory.CategoryStruct.id X = 0) | null | false |
Multiset.sup_eq_union | Mathlib.Data.Multiset.UnionInter | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Multiset α), s ⊔ t = s ∪ t | null | true |
Aesop.ForwardRuleStateStats._sizeOf_1 | Aesop.Stats.Basic | Aesop.ForwardRuleStateStats → ℕ | null | false |
MonoidHom.id._proof_1 | Mathlib.Algebra.Group.Hom.Defs | ∀ (M : Type u_1) [inst : MulOne M], 1 = 1 | null | false |
Ideal.comap._proof_3 | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_1} {S : Type u_2} {F : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
(f : F) [RingHomClass F R S] (I : Ideal S) {x y : R}, x ∈ ⇑f ⁻¹' ↑I → y ∈ ⇑f ⁻¹' ↑I → x + y ∈ ⇑f ⁻¹' ↑I | null | false |
NormedCommRing.toNonUnitalNormedCommRing._proof_12 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} [β : NormedCommRing α] (x y : α), dist x y = ‖-x + y‖ | null | false |
Homotopy.symm._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 : HomologicalComplex V c} {f g : C ⟶ D} (h : Homotopy f g) (i j : ι),
¬c.Rel j i → (-h.hom) i j = 0 | null | false |
IsAddQuotientCoveringMap.homeomorph_comp_iff | Mathlib.Topology.Covering.Quotient | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {f : E → X} {G : Type u_3}
[inst_2 : AddGroup G] [inst_3 : AddAction G E] {Y : Type u_4} [inst_4 : TopologicalSpace Y] (φ : X ≃ₜ Y),
IsAddQuotientCoveringMap (⇑φ ∘ f) G ↔ IsAddQuotientCoveringMap f G | null | true |
Valued.integer.norm_unit | Mathlib.Topology.Algebra.Valued.LocallyCompact | ∀ {K : Type u_1} [inst : NontriviallyNormedField K] [inst_1 : IsUltrametricDist K] (u : (↥(Valued.integer K))ˣ),
‖↑u‖ = 1 | null | true |
NumberField.instCommRingRingOfIntegers._proof_31 | Mathlib.NumberTheory.NumberField.Basic | ∀ (K : Type u_1) [inst : Field K], autoParam (∀ (n : ℕ), ↑(n + 1) = ↑n + 1) AddMonoidWithOne.natCast_succ._autoParam | null | false |
_private.Lean.Meta.Tactic.Cleanup.0.Lean.Meta.cleanupCore.addUsedFVars._unsafe_rec | Lean.Meta.Tactic.Cleanup | Lean.Expr → StateRefT' IO.RealWorld (Bool × Lean.FVarIdSet) Lean.MetaM Unit | null | false |
CategoryTheory.GradedObject.CofanMapObjFun.inj_iso_hom | Mathlib.CategoryTheory.GradedObject | ∀ {I : Type u_1} {J : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{v_1, u_4} C]
{X : CategoryTheory.GradedObject I C} {p : I → J} {j : J} [inst_1 : X.HasMap p] {c : X.CofanMapObjFun p j}
(hc : CategoryTheory.Limits.IsColimit c) (i : I) (hi : p i = j),
CategoryTheory.CategoryStruct.comp (CategoryTheor... | null | true |
geom_sum₂_Ico | Mathlib.Algebra.Field.GeomSum | ∀ {K : Type u_1} [inst : Field K] {x y : K},
x ≠ y → ∀ {m n : ℕ}, m ≤ n → ∑ i ∈ Finset.Ico m n, x ^ i * y ^ (n - 1 - i) = (x ^ n - y ^ (n - m) * x ^ m) / (x - y) | null | true |
Lean.Parser.Term.binderTactic.parenthesizer | Lean.Parser.Term.Basic | Lean.PrettyPrinter.Parenthesizer | null | true |
CategoryTheory.Triangulated.TStructure.ge | Mathlib.CategoryTheory.Triangulated.TStructure.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasZeroObject C] →
[inst_3 : CategoryTheory.HasShift C ℤ] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[inst_5 : Ca... | the predicate of objects that are `≥ n` for `n : ℤ`. | true |
_private.Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace.0.RestrictedProduct.continuous_dom_pi._simp_1_1 | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
Continuous f = ∀ (x : X), ContinuousAt f x | null | false |
_private.Lean.Linter.UnusedVariables.0.Lean.Linter.mkIgnoreFnImpl.match_3 | Lean.Linter.UnusedVariables | (motive : Lean.ImportM.Context → Sort u_1) →
(x : Lean.ImportM.Context) →
((env : Lean.Environment) → (opts : Lean.Options) → motive { env := env, opts := opts }) → motive x | null | false |
Polynomial.resultant_taylor | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (r : R),
((Polynomial.taylor r) f).resultant ((Polynomial.taylor r) g) = f.resultant g | `Res(f(x + r), g(x + r)) = Res(f, g)`. | true |
TestFunction.toBoundedContinuousFunctionCLM._proof_1 | Mathlib.Analysis.Distribution.TestFunction | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F], IsBoundedSMul ℝ F | null | false |
List.mkSlice_rii_eq_mkSlice_rci | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : List α}, Std.Rii.Sliceable.mkSlice xs *...* = Std.Rci.Sliceable.mkSlice xs (0...*) | null | true |
Int8.toNatClampNeg_eq_zero_iff._simp_1 | Init.Data.SInt.Lemmas | ∀ {n : Int8}, (n.toNatClampNeg = 0) = (n ≤ 0) | null | false |
USize.eq_of_toFin_eq | Init.Data.UInt.Lemmas | ∀ {a b : USize}, a.toFin = b.toFin → a = b | null | true |
Std.TreeSet.getD_maxD | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp],
t.isEmpty = false → ∀ {fallback fallback' : α}, t.getD (t.maxD fallback) fallback' = t.maxD fallback | null | true |
_private.Mathlib.Data.Sym.Basic.0.Sym.count_coe_fill_of_ne._simp_1_1 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {a b : α} {n : ℕ}, (b ∈ Multiset.replicate n a) = (n ≠ 0 ∧ b = a) | null | false |
Nat.chineseRemainderOfList.match_1 | Mathlib.Data.Nat.ChineseRemainder | {ι : Type u_1} →
(s : ι → ℕ) →
(motive : (x : List ι) → List.Pairwise (Function.onFun Nat.Coprime s) x → Sort u_2) →
(x : List ι) →
(x_1 : List.Pairwise (Function.onFun Nat.Coprime s) x) →
((x : List.Pairwise (Function.onFun Nat.Coprime s) []) → motive [] x) →
((i : ι) →
... | null | false |
AddConstEquiv.instPowInt._proof_1 | Mathlib.Algebra.AddConstMap.Equiv | ∀ {G : Type u_1} [inst : Add G] {a : G} (e : AddConstEquiv G G a a) (n : ℤ) (x : G),
(↑e ^ n).toFun (x + a) = (↑e ^ n).toFun x + a | null | false |
IsCoxeterGroup | Mathlib.GroupTheory.Coxeter.Basic | (W : Type u) → [Group W] → Prop | A group is a Coxeter group if it admits a Coxeter system for some Coxeter matrix `M`. | true |
Real.HolderTriple.holderConjugate_div_div | Mathlib.Basic.Real.ConjExponents | ∀ {p q r : ℝ}, p.HolderTriple q r → (p / r).HolderConjugate (q / r) | null | true |
MonoidAlgebra.mapRingHom_comp_algebraMap | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_1} {S : Type u_2} {M : Type u_7} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Monoid M]
(f : R →+* S),
(MonoidAlgebra.mapRingHom M f).comp (algebraMap R (MonoidAlgebra R M)) = (algebraMap S (MonoidAlgebra S M)).comp f | null | true |
_private.Lean.Compiler.LCNF.Main.0.Lean.Compiler.LCNF.PassManager.run.match_3 | Lean.Compiler.LCNF.Main | (motive : Option (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Phase.mono.toPurity) → Sort u_1) →
(__do_lift : Option (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Phase.mono.toPurity)) →
((decl : Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Phase.mono.toPurity) → motive (some decl)) →
((x : Option (Lean.Compiler... | null | false |
HasStrictFDerivAt.log | Mathlib.Analysis.SpecialFunctions.Log.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {x : E} {f' : StrongDual ℝ E},
HasStrictFDerivAt f f' x → f x ≠ 0 → HasStrictFDerivAt (fun x => Real.log (f x)) ((f x)⁻¹ • f') x | null | true |
LinearMap.vecEmpty | Mathlib.LinearAlgebra.Pi | {R : Type u} →
{M : Type v} →
{M₃ : Type y} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid M₃] → [inst_3 : Module R M] → [inst_4 : Module R M₃] → M →ₗ[R] Fin 0 → M₃ | The linear map defeq to `Matrix.vecEmpty` | true |
_private.Mathlib.NumberTheory.RamificationInertia.Basic.0.Ideal.FinrankQuotientMap.linearIndependent_of_nontrivial._simp_1_7 | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N] {G : Type u_7}
[inst_2 : FunLike G M N] [AddMonoidHomClass G M N] (g : G) (f : ι → M) (s : Finset ι),
∑ x ∈ s, g (f x) = g (∑ x ∈ s, f x) | null | false |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.step₂.quasiIsoAt_ι._proof_1_1 | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ (n : ℤ), n ≤ n | null | false |
_private.Init.Data.Dyadic.Round.0.Dyadic.precision_roundDown.match_1_1 | Init.Data.Dyadic.Round | ∀ (motive : Dyadic → Prop) (x : Dyadic),
(∀ (_ : Unit), motive Dyadic.zero) → (∀ (n k : ℤ) (hn : n % 2 = 1), motive (Dyadic.ofOdd n k hn)) → motive x | null | false |
Finset.pimage_eq_image_filter | Mathlib.Data.Finset.PImage | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α →. β} [inst_1 : (x : α) → Decidable (f x).Dom]
{s : Finset α}, Finset.pimage f s = Finset.image (fun x => (f ↑x).get ⋯) {x ∈ s | (f x).Dom}.attach | Rewrite `s.pimage f` in terms of `Finset.filter`, `Finset.attach`, and `Finset.image`. | true |
AlgebraicGeometry.PrimeSpectrum.Top.eq_1 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ (R : Type u) [inst : CommRing R], AlgebraicGeometry.PrimeSpectrum.Top R = ↧(PrimeSpectrum R) | null | true |
AlgebraicGeometry.Scheme.Hom.normalizationCoprodIso._proof_4 | Mathlib.AlgebraicGeometry.Normalization | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [inst : AlgebraicGeometry.QuasiCompact f]
[inst_1 : AlgebraicGeometry.QuasiSeparated f] {U V : AlgebraicGeometry.Scheme} {iU : U ⟶ X} {iV : V ⟶ X}
(e : CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.BinaryCofan.mk iU iV))
[inst_2 : AlgebraicGeometry.QuasiComp... | null | false |
AffineSubspace.finite_of_finDim_ne_zero | Mathlib.LinearAlgebra.AffineSpace.Dimension | ∀ {R : Type u} {V : Type v} {A : Type a} [inst : AddCommGroup V] [inst_1 : AddTorsor V A] [inst_2 : Ring R]
[inst_3 : Module R V] [StrongRankCondition R] (s : AffineSubspace R A) [Module.Free R ↥s.direction],
s.finDim ≠ 0 → Module.Finite R ↥s.direction | null | true |
ENNReal.mulRightOrderIso._proof_2 | Mathlib.Basic.ENNReal.Inv | ∀ (a : ENNReal) (ha : IsUnit a) {a_1 b : ENNReal}, ha.unit.mulRight a_1 ≤ ha.unit.mulRight b ↔ a_1 ≤ b | null | false |
SimpleGraph.Hom.sum_apply | Mathlib.Combinatorics.SimpleGraph.Sum | ∀ {V : Type u_3} {V' : Type u_4} {W : Type u_5} {W' : Type u_6} {G : SimpleGraph V} {H : SimpleGraph W}
{G' : SimpleGraph V'} {H' : SimpleGraph W'} (f : G →g G') (g : H →g H') (a : V ⊕ W), (f.sum g) a = Sum.map (⇑f) (⇑g) a | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.