name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
QuotientAddGroup.lift._proof_2 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} {M : Type u_2} [inst : AddGroup G] [inst_1 : AddMonoid M] (N : AddSubgroup G) [nN : N.Normal]
(φ : G →+ M), N ≤ φ.ker → QuotientAddGroup.con N ≤ AddCon.ker φ | null | false |
SignType.ofNat | Mathlib.Data.Sign.Defs | ℕ → SignType | null | true |
Module.Flat.tensorSubmoduleAlgebraEquiv._proof_1 | Mathlib.RingTheory.PicardGroup | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
SMulCommClass R A A | null | false |
Lean.Doc.instMonadStateOfInternalStateDocM | Lean.Elab.DocString | MonadStateOf Lean.Doc.InternalState Lean.Doc.DocM | null | true |
MeasureTheory.tendsto_setIntegral_of_L1 | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} {ι : Type u_6} (f : α → G),
MeasureTheory.AEStronglyMeasurable f μ →
∀ {F : ι → α → G} {l : Filter ι},
(∀ᶠ (i : ι) in l, MeasureTheory.Integrable (F i) μ) →
... | If `F i → f` in `L1`, then `∫ x in s, F i x ∂μ → ∫ x in s, f x ∂μ`. | true |
StarMul.noConfusion | Mathlib.Algebra.Star.Basic | {P : Sort u_1} →
{R : Type u} →
{inst : Mul R} →
{t : StarMul R} →
{R' : Type u} →
{inst' : Mul R'} → {t' : StarMul R'} → R = R' → inst ≍ inst' → t ≍ t' → StarMul.noConfusionType P t t' | null | false |
Filter.Germ.instSemigroup._proof_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {M : Type u_2} [inst : Semigroup M] (a b c : l.Germ M), a * b * c = a * (b * c) | null | false |
LinearMap.index_of_subsingleton | Mathlib.Algebra.Module.LinearMap.Index | ∀ {M : Type u_1} {N : Type u_2} [inst : AddCommGroup M] [inst_1 : AddCommGroup N] {R : Type u_3} [inst_2 : Ring R]
[inst_3 : Module R M] [inst_4 : Module R N] {f : M →ₗ[R] N} [Subsingleton R], f.index = 0 | null | true |
FractionalIdeal.absNorm_div_norm_eq_absNorm_div_norm | Mathlib.RingTheory.FractionalIdeal.Norm | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] [inst_2 : Module.Free ℤ R] [Module.Finite ℤ R]
{K : Type u_2} [inst_4 : CommRing K] [inst_5 : Algebra R K] [IsFractionRing R K]
{I : FractionalIdeal (nonZeroDivisors R) K} (a : ↥(nonZeroDivisors R)) (I₀ : Ideal R),
a • ↑I = Submodule.map (Algebra.... | null | true |
PMF.ofFinset.congr_simp | Mathlib.Probability.ProbabilityMassFunction.Constructions | ∀ {α : Type u_1} (f f_1 : α → ENNReal) (e_f : f = f_1) (s s_1 : Finset α) (e_s : s = s_1) (h : ∑ a ∈ s, f a = 1)
(h' : ∀ a ∉ s, f a = 0), PMF.ofFinset f s h h' = PMF.ofFinset f_1 s_1 ⋯ ⋯ | null | true |
continuous_algebraMap_iff_smul | Mathlib.Topology.Algebra.Algebra | ∀ (R : Type u_1) (A : Type u) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : TopologicalSpace R] [inst_4 : TopologicalSpace A] [ContinuousMul A],
Continuous ⇑(algebraMap R A) ↔ Continuous fun p => p.1 • p.2 | null | true |
Int.mul_tmod_left | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), (a * b).tmod b = 0 | null | true |
Lean.LocalDeclKind | Lean.LocalContext | Type | Whether a local declaration should be found by type class search, tactics, etc.
and shown in the goal display.
| true |
Subgroup.isRegularAtInfty_of_neg_one_mem | Mathlib.NumberTheory.ModularForms.Cusps | ∀ {R : Type u_1} [inst : Ring R] {𝒢 : Subgroup (GL (Fin 2) R)}, -1 ∈ 𝒢 → 𝒢.IsRegularAtInfty | null | true |
CategoryTheory.Functor.IsHomological | Mathlib.CategoryTheory.Triangulated.HomologicalFunctor | {C : Type u_1} →
{A : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.HasShift C ℤ] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} A] →
CategoryTheory.Functor C A →
[inst_3 : CategoryTheory.Limits.HasZeroObject C] →
[inst_4 : C... | A functor from a pretriangulated category to an abelian category is a homological functor
if it sends distinguished triangles to exact sequences. | true |
Lean.Lsp.ReferenceContext.rec | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.ReferenceContext → Sort u} →
((includeDeclaration : Bool) → motive { includeDeclaration := includeDeclaration }) →
(t : Lean.Lsp.ReferenceContext) → motive t | null | false |
GromovHausdorff.auxGluing._proof_4 | Mathlib.Topology.MetricSpace.GromovHausdorff | ∀ (X : ℕ → Type) [inst : (n : ℕ) → MetricSpace (X n)] [inst_1 : ∀ (n : ℕ), CompactSpace (X n)]
[inst_2 : ∀ (n : ℕ), Nonempty (X n)] (n : ℕ), Isometry (GromovHausdorff.optimalGHInjl (X n) (X (n + 1))) | null | false |
ENNReal.essSup_piecewise | Mathlib.MeasureTheory.Function.EssSup | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal} {s : Set α}
[inst : DecidablePred fun x => x ∈ s] {g : α → ENNReal},
MeasurableSet s → essSup (s.piecewise f g) μ = max (essSup f (μ.restrict s)) (essSup g (μ.restrict sᶜ)) | null | true |
_private.Mathlib.Algebra.Polynomial.RuleOfSigns.0.Polynomial.signVariations_eraseLead_mul_X_sub_C._abel_1_6 | Mathlib.Algebra.Polynomial.RuleOfSigns | ∀ {R : Type u_1} [inst : Ring R] {P : Polynomial R} {η : R} (d : ℕ),
Polynomial.X * P - Polynomial.C η * P - (Polynomial.monomial (d + 1 + 1)) (P.coeff (d + 1)) -
((Polynomial.monomial (d + 1)) (P.coeff d) - (Polynomial.monomial (d + 1)) (η * P.coeff (d + 1))) =
Polynomial.X * P - Polynomial.C η * P -
... | null | false |
toBoolAlg_zero | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanRing α], toBoolAlg 0 = ⊥ | null | true |
Mathlib.Meta.Positivity.evalFinsetSum | Mathlib.Tactic.Positivity.Finset | Mathlib.Meta.Positivity.PositivityExt | The `positivity` extension which proves that `∑ i ∈ s, f i` is nonnegative if `f` is, and
positive if each `f i` is and `s` is nonempty.
TODO: The following example does not work
```
example (s : Finset ℕ) (f : ℕ → ℤ) (hf : ∀ n, 0 ≤ f n) : 0 ≤ s.sum f := by positivity
```
because `compareHyp` can't look for assumption... | true |
Equiv.mulActionWithZero._proof_1 | Mathlib.Algebra.GroupWithZero.Action.TransferInstance | ∀ (M₀ : Type u_2) {A : Type u_1} {B : Type u_3} (e : A ≃ B) [inst : MonoidWithZero M₀] [inst_1 : Zero B]
[inst_2 : MulActionWithZero M₀ B] (x y : M₀) (b : A), (x * y) • b = x • y • b | null | false |
IsLocalizedModule.mapExtendScalars | Mathlib.RingTheory.Localization.Module | {R : Type u_1} →
[inst : CommSemiring R] →
(S : Submonoid R) →
{M : Type u_2} →
{M' : Type u_3} →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid M'] →
[inst_3 : Module R M] →
[inst_4 : Module R M'] →
(f : M →ₗ[R] M') →
... | A linear map `M →ₗ[R] N` gives a map between localized modules `Mₛ →ₗ[Rₛ] Nₛ`. | true |
_private.Init.Grind.Offset.0.Lean.Grind.Nat.le_offset._proof_1_1 | Init.Grind.Offset | ∀ (a k : ℕ), ¬k ≤ a + k → False | null | false |
CategoryTheory.CommGrp.forget₂Grp_obj_one | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (A : CategoryTheory.CommGrp C),
CategoryTheory.MonObj.one = CategoryTheory.MonObj.one | null | true |
FiniteField.instFieldExtension._proof_22 | Mathlib.FieldTheory.Finite.Extension | ∀ (k : Type u_1) [inst : Field k] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP k p] (n : ℕ),
autoParam (∀ (x : FiniteField.Extension k p n), FiniteField.instFieldExtension._aux_20 k p n 0 x = 1)
Monoid.npow_zero._autoParam | null | false |
AffineBasis.tot | Mathlib.LinearAlgebra.AffineSpace.Basis | ∀ {ι : Type u_1} {k : Type u_5} {V : Type u_6} {P : Type u_7} [inst : AddCommGroup V] [inst_1 : AddTorsor V P]
[inst_2 : Ring k] [inst_3 : Module k V] (b : AffineBasis ι k P), affineSpan k (Set.range ⇑b) = ⊤ | null | true |
_private.Mathlib.Algebra.Order.Group.Pointwise.Interval.0.Set.inv_Ioc._simp_1_1 | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioc a b = Set.Ioi a ∩ Set.Iic b | null | false |
Topology.IsClosed_of | Mathlib.Topology.Defs.Basic | Lean.ParserDescr | Notation for `IsClosed` with respect to a non-standard topology. | true |
AddCommGrpCat.forget_commGrp_preserves_epi | Mathlib.Algebra.Category.Grp.EpiMono | (CategoryTheory.forget AddCommGrpCat).PreservesEpimorphisms | null | true |
IsAdicComplete.toIsPrecomplete | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} {inst : CommRing R} {I : Ideal R} {M : Type u_4} {inst_1 : AddCommGroup M} {inst_2 : Module R M}
[self : IsAdicComplete I M], IsPrecomplete I M | null | true |
_private.Mathlib.Data.Finset.Insert.0.Finset.insert_comm._proof_1_1 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} [inst : DecidableEq α] (a b : α) (s : Finset α), insert a (insert b s) = insert b (insert a s) | null | false |
Std.Tactic.BVDecide.BVExpr.WithCache.cache | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | {α : Type u} →
{aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit} →
Std.Tactic.BVDecide.BVExpr.WithCache α aig → Std.Tactic.BVDecide.BVExpr.Cache aig | null | true |
MonoidHom.FixedPointFree.commGroupOfInvolutive | Mathlib.GroupTheory.FixedPointFree | {F : Type u_1} →
{G : Type u_2} →
[inst : Group G] →
[inst_1 : FunLike F G G] →
[MonoidHomClass F G G] →
{φ : F} → [Finite G] → MonoidHom.FixedPointFree ⇑φ → Function.Involutive ⇑φ → CommGroup G | If a finite group admits a fixed-point-free involution, then it is commutative. | true |
CategoryTheory.RegularMono._sizeOf_1 | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} → {X Y : C} → {f : X ⟶ Y} → [SizeOf C] → CategoryTheory.RegularMono f → ℕ | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.isEmpty_filter_eq_false_iff._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
mem_selfAdjointMatricesSubmodule' | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₂ : Type u_3} [inst : CommRing R₂] {n : Type u_5} [inst_1 : Fintype n] (J A : Matrix n n R₂)
[inst_2 : DecidableEq n], A ∈ selfAdjointMatricesSubmodule J ↔ J.IsSelfAdjoint A | null | true |
FirstOrder.Language.PartialEquiv.mk.inj | Mathlib.ModelTheory.PartialEquiv | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} {inst : L.Structure M} {inst_1 : L.Structure N}
{dom : L.Substructure M} {cod : L.Substructure N} {toEquiv : L.Equiv ↥dom ↥cod} {dom_1 : L.Substructure M}
{cod_1 : L.Substructure N} {toEquiv_1 : L.Equiv ↥dom_1 ↥cod_1},
{ dom := dom, cod := cod, toEquiv := toE... | null | true |
Condensed.locallyConstantIsoFinYoneda | Mathlib.Condensed.Discrete.Colimit | (F : CategoryTheory.Functor Profiniteᵒᵖ (Type (u + 1))) →
FintypeCat.toProfinite.op.comp
(Condensed.locallyConstantPresheaf
(F.obj (FintypeCat.toProfinite.op.obj (Opposite.op (FintypeCat.of PUnit.{u + 1}))))) ≅
Condensed.finYoneda F | `locallyConstantPresheaf` restricted to finite sets is isomorphic to `finYoneda F`. | true |
DirectLimit.instMulZeroOneClass._proof_1 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_3} {T : ⦃i j : ι⦄ → i ≤ j → Type u_2}
[inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)] [inst_2 : (i : ι) → MulZeroOneClass (G i)]
[∀ (i j : ι) (h : i ≤ j), MonoidWithZeroHomClass (T h) (G i) (G j)] (i j : ι) (h : i ≤ j),
MonoidHomClass (T h) (G i)... | null | false |
CategoryTheory.Limits.Concrete.initial_of_empty_of_reflects | Mathlib.CategoryTheory.Limits.Shapes.ConcreteCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type w}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC]
[CategoryTheory.Limits.ReflectsColimit (CategoryTheory.Functor.empty C) (CategoryTheory.forget C)] (X : C),
IsEmp... | If `forget C` reflects initials and `ToType X` is empty, then `X` is initial. | true |
RatFunc.ofFractionRing_eq | Mathlib.FieldTheory.RatFunc.Basic | ∀ {K : Type u} [inst : CommRing K] [inst_1 : IsDomain K],
RatFunc.ofFractionRing =
⇑(IsLocalization.algEquiv (nonZeroDivisors (Polynomial K)) (FractionRing (Polynomial K)) (RatFunc K)) | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Matching.0.SimpleGraph.IsCycles.other_adj_of_adj._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Matching | ∀ {V : Type u} (G : SimpleGraph V) (v w : V), G.Adj v w = (w ∈ G.neighborSet v) | null | false |
AddCommGroup.toDistribLattice.eq_1 | Mathlib.Algebra.Order.Group.Lattice | ∀ (α : Type u_2) [inst : Lattice α] [inst_1 : AddCommGroup α] [inst_2 : AddLeftMono α],
AddCommGroup.toDistribLattice α = { toLattice := inst, le_sup_inf := ⋯ } | null | true |
TopCat.coconeOfCoconeForget._proof_2 | Mathlib.Topology.Category.TopCat.Limits.Basic | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] {F : CategoryTheory.Functor J TopCat}
(c : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.forget TopCat))) (j j' : J) (φ : j ⟶ j'),
CategoryTheory.CategoryStruct.comp (F.map φ)
(TopCat.ofHom { toFun := ⇑(CategoryTheory.ConcreteCategory.hom (... | null | false |
Aesop.instInhabitedMVarClusterData.default | Aesop.Tree.Data | {Goal Rapp : Type} → Aesop.MVarClusterData Goal Rapp | null | true |
ContinuousAffineMap.decompEquiv_symm_apply | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ (R : Type u_1) (V : Type u_3) {W : Type u_4} (Q : Type u_5) [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace V] [inst_4 : IsTopologicalAddGroup V] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace W] [inst_8 : AddTorsor W Q] [inst_9 : TopologicalS... | null | true |
_private.Mathlib.Tactic.ClickSuggestions.FindPremises.0.Mathlib.Tactic.ClickSuggestions.Entries.mk.inj | Mathlib.Tactic.ClickSuggestions.FindPremises | ∀
{rw :
Array
(Lean.Meta.RefinedDiscrTree.Key × Lean.Meta.RefinedDiscrTree.LazyEntry × Mathlib.Tactic.ClickSuggestions.RwLemma)}
{grw :
Array
(Lean.Meta.RefinedDiscrTree.Key ×
Lean.Meta.RefinedDiscrTree.LazyEntry × Mathlib.Tactic.ClickSuggestions.GrwLemma)}
{app :
Array
(Lean... | null | true |
Lean.LocalDecl.collectFVars | Lean.Meta.CollectFVars | Lean.LocalDecl → StateRefT' IO.RealWorld Lean.CollectFVars.State Lean.MetaM Unit | null | true |
Lean.Server.TransientWorkerILean.mk.injEq | Lean.Server.References | ∀ (moduleUri : Lean.Lsp.DocumentUri) (version : ℕ) (directImports : Lean.Server.DirectImports)
(isSetupFailure? : Option Bool) (refs : Lean.Lsp.ModuleRefs) (decls : Lean.Lsp.Decls)
(moduleUri_1 : Lean.Lsp.DocumentUri) (version_1 : ℕ) (directImports_1 : Lean.Server.DirectImports)
(isSetupFailure?_1 : Option Bool) ... | null | true |
CategoryTheory.SimplicialThickening.instCategoryHom._proof_3 | Mathlib.AlgebraicTopology.SimplicialNerve | ∀ {J : Type u_1} [inst : LinearOrder J] (i j : CategoryTheory.SimplicialThickening J),
autoParam
(∀ {W X Y Z : CategoryTheory.SimplicialThickening.Path i.as j.as} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h =
CategoryTheory.Categ... | null | false |
RightPreLieAlgebra.instLeftPreLieAlgebraMulOpposite._proof_1 | Mathlib.Algebra.NonAssoc.PreLie.Basic | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : RightPreLieRing L] [inst_2 : RightPreLieAlgebra R L],
IsScalarTower R Lᵐᵒᵖ Lᵐᵒᵖ | null | false |
CategoryTheory.Functor.RepresentableBy.yoneda | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → (X : C) → (CategoryTheory.yoneda.obj X).RepresentableBy X | `yoneda.obj X` is represented by `X`. | true |
instNonUnitalNonAssocRingCommutatorRing._proof_28 | Mathlib.Algebra.Lie.NonUnitalNonAssocAlgebra | ∀ (L : Type u_1) (this : NonUnitalNonAssocRing L) (a : CommutatorRing L), 0 * a = 0 | null | false |
Lean.Parser.Term.matchAltsWhereDecls.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | null | true |
CategoryTheory.Localization.SmallShiftedHom.mk₀_comp_mk₀Inv | Mathlib.CategoryTheory.Localization.SmallShiftedHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {W : CategoryTheory.MorphismProperty C} {M : Type w'}
[inst_1 : AddMonoid M] [inst_2 : CategoryTheory.HasShift C M] {X Y : C}
[inst_3 : CategoryTheory.Localization.HasSmallLocalizedShiftedHom W M X Y]
[inst_4 : CategoryTheory.Localization.HasSmallLocaliz... | null | true |
Lean.Elab.Term.SyntheticMVarKind.typeClass.inj | Lean.Elab.Term.TermElabM | ∀ {extraErrorMsg? extraErrorMsg?_1 : Option Lean.MessageData},
Lean.Elab.Term.SyntheticMVarKind.typeClass extraErrorMsg? =
Lean.Elab.Term.SyntheticMVarKind.typeClass extraErrorMsg?_1 →
extraErrorMsg? = extraErrorMsg?_1 | null | true |
Lean.PrefixTreeNode.below_2 | Lean.Data.PrefixTree | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
{motive_1 : Lean.PrefixTreeNode α β cmp → Sort u_1} →
{motive_2 : Std.TreeMap.Raw α (Lean.PrefixTreeNode α β cmp) cmp → Sort u_1} →
{motive_3 : Std.DTreeMap.Raw α (fun x => Lean.PrefixTreeNode α β cmp) cmp → Sort u_1} →
{... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.entryAtIdx_eq._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Mathlib.Notation3.MatchState.noConfusion | Mathlib.Util.Notation3 | {P : Sort u} → {t t' : Mathlib.Notation3.MatchState} → t = t' → Mathlib.Notation3.MatchState.noConfusionType P t t' | null | false |
_private.Mathlib.Algebra.Polynomial.Degree.Units.0.Polynomial.isUnit_iff.match_1_1 | Mathlib.Algebra.Polynomial.Degree.Units | ∀ {R : Type u_1} [inst : Semiring R] {p : Polynomial R} (motive : (∃ r, IsUnit r ∧ Polynomial.C r = p) → Prop)
(x : ∃ r, IsUnit r ∧ Polynomial.C r = p), (∀ (w : R) (hr : IsUnit w) (hrp : Polynomial.C w = p), motive ⋯) → motive x | null | false |
_private.Mathlib.Tactic.Linter.FindDeprecations.0.Mathlib.Tactic.DeprecationInfo.mk.noConfusion | Mathlib.Tactic.Linter.FindDeprecations | {P : Sort u} →
{module decl : Lean.Name} →
{rgStart rgStop : Lean.Position} →
{since : String} →
{module' decl' : Lean.Name} →
{rgStart' rgStop' : Lean.Position} →
{since' : String} →
{ module := module, decl := decl, rgStart := rgStart, rgStop := rgStop, since :=... | null | false |
Matroid.Indep.isNonloop_of_mem | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {e : α} {I : Set α}, M.Indep I → e ∈ I → M.IsNonloop e | null | true |
MonoidAlgebra.liftNCRingHom_single | Mathlib.Algebra.MonoidAlgebra.Lift | ∀ {k : Type u₁} {G : Type u₂} {R : Type u_2} [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : Semiring R] (f : k →+* R)
(g : G →* R) (h_comm : ∀ (x : k) (y : G), Commute (f x) (g y)) (a : G) (b : k),
(MonoidAlgebra.liftNCRingHom f g h_comm) (MonoidAlgebra.single a b) = f b * g a | null | true |
AddGroupSeminorm.instSupSet._proof_2 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : AddGroup E] (s : Set (AddGroupSeminorm E)),
BddAbove s → ∀ (x y : E), ⨆ p, ↑p (x + y) ≤ (⨆ p, ↑p x) + ⨆ p, ↑p y | null | false |
CategoryTheory.Functor.IsRepresentedBy.representableBy | Mathlib.CategoryTheory.RepresentedBy | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor Cᵒᵖ (Type w)} →
{X : C} → {x : F.obj (Opposite.op X)} → F.IsRepresentedBy x → F.RepresentableBy X | The canonical representation induced by the universal element `x : F.obj X`. | true |
CategoryTheory.Bicategory.Adjunction.homEquiv₂._proof_1 | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b c : B} {l : b ⟶ c} {r : c ⟶ b}
(adj : CategoryTheory.Bicategory.Adjunction l r) {g : a ⟶ b} {h : a ⟶ c}
(α : CategoryTheory.CategoryStruct.comp g l ⟶ h),
(fun γ =>
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight γ l)
... | null | false |
integrable_cexp_quadratic' | Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform | ∀ {b : ℂ},
b.re < 0 → ∀ (c d : ℂ), MeasureTheory.Integrable (fun x => Complex.exp (b * ↑x ^ 2 + c * ↑x + d)) MeasureTheory.volume | null | true |
Ordinal.IsFundamentalSeq.id | Mathlib.SetTheory.Ordinal.FundamentalSequence | ∀ {o : Ordinal.{u_1}}, o ≤ o.cof.ord → Ordinal.IsFundamentalSeq id | A regular ordinal `o` has a fundamental sequence given by all smaller ordinals. | true |
Turing.TM2.Stmt.ctorElim | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{Λ : Type u_3} →
{σ : Type u_4} →
{motive : Turing.TM2.Stmt Γ Λ σ → Sort u} →
(ctorIdx : ℕ) →
(t : Turing.TM2.Stmt Γ Λ σ) → ctorIdx = t.ctorIdx → Turing.TM2.Stmt.ctorElimType ctorIdx → motive t | null | false |
Lean.Doc.Inline.emph.injEq | Lean.DocString.Types | ∀ {i : Type u} (content content_1 : Array (Lean.Doc.Inline i)),
(Lean.Doc.Inline.emph content = Lean.Doc.Inline.emph content_1) = (content = content_1) | null | true |
SimpleGraph.isEdgeReachable_two | Mathlib.Combinatorics.SimpleGraph.Connectivity.EdgeConnectivity | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V},
G.IsEdgeReachable 2 u v ↔ ∀ (e : Sym2 V), (G.deleteEdges {e}).Reachable u v | null | true |
CategoryTheory.Functor.toPrefunctor | Mathlib.CategoryTheory.Functor.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} → [inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor C D → C ⥤q D | The prefunctor between the underlying quivers. | true |
Lean.Meta.saveState | Lean.Meta.Basic | Lean.MetaM Lean.Meta.SavedState | null | true |
_private.Mathlib.Data.Finsupp.Basic.0.Finsupp.embDomain_trans_apply._simp_1_1 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {M : Type u_5} [inst : AddCommMonoid M] {v : α →₀ M} {f : α → β}
{g : β → γ}, Finsupp.mapDomain g (Finsupp.mapDomain f v) = Finsupp.mapDomain (g ∘ f) v | null | false |
AffineSubspace.map_bot | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V₁ : Type u_2} {P₁ : Type u_3} {V₂ : Type u_4} {P₂ : Type u_5} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : AddCommGroup V₂]
[inst_5 : Module k V₂] [inst_6 : AddTorsor V₂ P₂] (f : P₁ →ᵃ[k] P₂), AffineSubspace.map f ⊥ = ⊥ | null | true |
Lean.Constructor.mk.injEq | Lean.Declaration | ∀ (name : Lean.Name) (type : Lean.Expr) (name_1 : Lean.Name) (type_1 : Lean.Expr),
({ name := name, type := type } = { name := name_1, type := type_1 }) = (name = name_1 ∧ type = type_1) | null | true |
_private.Std.Data.DTreeMap.Lemmas.0.Break.runK.match_1.eq_2 | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (h_1 : (a : α) → motive (some a)) (h_2 : Unit → motive none),
(match none with
| some a => h_1 a
| none => h_2 ()) =
h_2 () | null | true |
Filter.eventually_bind._simp_1 | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {m : α → Filter β} {p : β → Prop},
(∀ᶠ (y : β) in f.bind m, p y) = ∀ᶠ (x : α) in f, ∀ᶠ (y : β) in m x, p y | null | false |
CategoryTheory.sum.match_3 | Mathlib.CategoryTheory.Sums.Basic | (C : Type u_1) →
(D : Type u_2) →
(motive : C ⊕ D → Sort u_3) →
(X : C ⊕ D) → ((X : C) → motive (Sum.inl X)) → ((X : D) → motive (Sum.inr X)) → motive X | null | false |
_private.Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves.0.CategoryTheory.regularTopology.equalizerCondition_w._simp_1_2 | Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves | ∀ {C : Type u₁} [inst : CategoryTheory.CategoryStruct.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp g.op f.op = (CategoryTheory.CategoryStruct.comp f g).op | null | false |
_private.Mathlib.Tactic.Ring.Common.0.Mathlib.Tactic.Ring.Common.instMonadLiftTOptionTOfMonad_mathlib | Mathlib.Tactic.Ring.Common | {m : Type u_2 → Type u_3} →
{m' : Type u_2 → Type u_4} → [Monad m] → [Monad m'] → [MonadLiftT m m'] → MonadLiftT (OptionT m) (OptionT m') | null | true |
PartialDiffeomorph.trans._proof_2 | Mathlib.Geometry.Manifold.LocalDiffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_9} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {F' : Type u_5}
[inst_5 : NormedAddCommGroup F'] [inst_6 : NormedSpace 𝕜 F'] {H₁ : Type u_3} [inst_7 : Topologi... | null | false |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FlatMap.0.Std.IterM.step_flattenAfter.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FlatMap | ∀ {α α₂ β : Type u_1} {m : Type u_1 → Type u_2} [inst : Std.Iterator α m (Std.IterM m β)]
{it₁ : Std.IterM m (Std.IterM m β)} (motive : it₁.Step → Sort u_3) (it₁' : Std.IterM m (Std.IterM m β))
(it₂' : Std.IterM m β) (h : it₁.IsPlausibleStep (Std.IterStep.yield it₁' it₂'))
(h_1 :
(it₁' : Std.IterM m (Std.Iter... | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.isClosed_lattice._proof_1_1 | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ (L : PeriodPair), DiscreteTopology ↥L.lattice.toAddSubgroup | null | false |
CategoryTheory.MorphismProperty.isLocal_antitone | Mathlib.CategoryTheory.ObjectProperty.Local | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W W' : CategoryTheory.MorphismProperty C},
W ≤ W' → W'.isLocal ≤ W.isLocal | null | true |
Irrational.of_mul_ratCast | Mathlib.NumberTheory.Real.Irrational | ∀ (q : ℚ) {x : ℝ}, Irrational (x * ↑q) → Irrational x | null | true |
Set.Finite.cast_ncard_eq | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α}, s.Finite → ↑s.ncard = s.encard | null | true |
List.chooseX.match_1 | Mathlib.Data.List.Defs | ∀ {α : Type u_1} (p : α → Prop) (l : α) (ls : List α) (x : α) (motive : x ∈ l :: ls ∧ p x → Prop)
(x_1 : x ∈ l :: ls ∧ p x), (∀ (o : x ∈ l :: ls) (h₂ : p x), motive ⋯) → motive x_1 | null | false |
LinearMap.transvection.comp_of_left_eq | Mathlib.LinearAlgebra.Transvection.Basic | ∀ {R : Type u_1} {V : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid V] [inst_2 : Module R V]
{f : Module.Dual R V} {v w : V},
f w = 0 → LinearMap.transvection f v ∘ₗ LinearMap.transvection f w = LinearMap.transvection f (v + w) | null | true |
AlgebraicGeometry.instIsLocallyArtinianFiberOfLocallyQuasiFinite | Mathlib.AlgebraicGeometry.Morphisms.QuasiFinite | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.LocallyQuasiFinite f] (y : ↥Y),
AlgebraicGeometry.IsLocallyArtinian (AlgebraicGeometry.Scheme.Hom.fiber f y) | null | true |
ENNReal.mul_eq_left | Mathlib.Data.ENNReal.Operations | ∀ {a b : ENNReal}, a ≠ 0 → a ≠ ⊤ → (a * b = a ↔ b = 1) | null | true |
IsGaloisGroup.fixedPoints_bot | Mathlib.FieldTheory.Galois.IsGaloisGroup | ∀ (G : Type u_1) (K : Type u_3) (L : Type u_4) [inst : Group G] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra K L] [inst_4 : MulSemiringAction G L] [inst_5 : SMulCommClass G K L],
FixedPoints.intermediateField ↥⊥ = ⊤ | null | true |
Equiv.piOptionEquivProd_apply | Mathlib.Logic.Equiv.Basic | ∀ {α : Type u_10} {β : Option α → Type u_9} (f : (a : Option α) → β a),
Equiv.piOptionEquivProd f = (f none, fun a => f (some a)) | null | true |
MeasureTheory.ae_eq_comp | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {β : Type u_3} {δ : Type u_4} {m0 : MeasurableSpace α} [inst : MeasurableSpace β]
{μ : MeasureTheory.Measure α} {f : α → β} {g g' : β → δ},
AEMeasurable f μ → g =ᵐ[MeasureTheory.Measure.map f μ] g' → g ∘ f =ᵐ[μ] g' ∘ f | null | true |
_private.Mathlib.GroupTheory.SpecificGroups.Cyclic.Basic.0.isCyclic_iff_exists_orderOf_eq_natCard._simp_1_2 | Mathlib.GroupTheory.SpecificGroups.Cyclic.Basic | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) [Finite ↥H], (H = ⊤) = (Nat.card ↥H = Nat.card G) | null | false |
exists_enorm_lt | Mathlib.Analysis.Normed.Group.Basic | ∀ (E : Type u_8) [inst : TopologicalSpace E] [inst_1 : ESeminormedAddMonoid E] [hbot : (nhdsWithin 0 {0}ᶜ).NeBot]
{c : ENNReal}, c ≠ 0 → ∃ x, x ≠ 0 ∧ ‖x‖ₑ < c | null | true |
CategoryTheory.Limits.biprod.braid_natural | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {W X Y Z : C} (f : X ⟶ Y) (g : Z ⟶ W),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.map f g)
(CategoryTheory.Limits.biprod... | The braiding isomorphism can be passed through a map by swapping the order. | true |
Module.End.rTensorAlgHom._proof_1 | Mathlib.RingTheory.TensorProduct.Maps | ∀ (R : Type u_1) (M : Type u_3) (N : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N], SMulCommClass R R (TensorProduct R M N) | null | false |
ByteArray.ofFn | Batteries.Data.ByteArray | {n : ℕ} → (Fin n → UInt8) → ByteArray | - `ofFn f` with `f : Fin n → UInt8` returns the byte array whose `i`th element is `f i`. - | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.