name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Meta.abstractProof | Lean.Meta.AbstractNestedProofs | {m : Type → Type} →
[inst : Monad m] →
[MonadLiftT Lean.MetaM m] →
[Lean.MonadEnv m] →
[Lean.MonadOptions m] →
[MonadFinally m] → Lean.Expr → optParam Bool true → optParam (Lean.Expr → m Lean.Expr) pure → m Lean.Expr | Abstracts the given proof into an auxiliary theorem, suitably pre-processing its type. | true |
Finset.consPiProd_fst | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α} {a : α} (f : α → Type u_3) (has : a ∉ s) (x : (i : α) → i ∈ Finset.cons a s has → f i),
(Finset.consPiProd f has x).1 = x a ⋯ | null | true |
normGroupNorm | Mathlib.Analysis.Normed.Group.Basic | (E : Type u_4) → [inst : NormedGroup E] → GroupNorm E | The norm of a normed group as a group norm. | true |
Submodule.injective_tensorToSpan | Mathlib.LinearAlgebra.Span.TensorProduct | ∀ {R : Type u_1} (A : Type u_2) {M : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M] [inst_6 : IsScalarTower R A M]
(p : Submodule R M) [Algebra.IsEpi R A] [Module.Flat R A], Function.Injective ⇑(Submodule.tens... | null | true |
Subspace.dualLift_injective | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {W : Subspace K V},
Function.Injective ⇑W.dualLift | null | true |
Finmap.instDecidableMem | Mathlib.Data.Finmap | {α : Type u} → {β : α → Type v} → [DecidableEq α] → (a : α) → (s : Finmap β) → Decidable (a ∈ s) | null | true |
Aesop.Safety.ctorIdx | Aesop.Rule | Aesop.Safety → ℕ | null | false |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.merge? | Lean.Elab.Tactic.Try | Lean.TSyntax `tactic → Lean.TSyntax `tactic → Option (Lean.TSyntax `tactic) | null | true |
PrimeMultiset.coeNat | Mathlib.Data.PNat.Factors | Coe PrimeMultiset (Multiset ℕ) | null | true |
Module.End.invtSubmodule.instBoundedOrderSubtypeSubmoduleMemSublattice | Mathlib.Algebra.Module.Submodule.Invariant | {R : Type u_1} →
{M : Type u_2} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → (f : Module.End R M) → BoundedOrder ↥f.invtSubmodule | null | true |
_private.Lean.Meta.FunInfo.0.Lean.Meta.getFunInfoAux.match_4 | Lean.Meta.FunInfo | (motive : Option (Array ℕ) → Sort u_1) →
(x : Option (Array ℕ)) →
((outParamPositions : Array ℕ) → motive (some outParamPositions)) → ((x : Option (Array ℕ)) → motive x) → motive x | null | false |
Polynomial.evalEval_surjective | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u_1} [inst : Semiring R] (x y : R), Function.Surjective (Polynomial.evalEval x y) | null | true |
Nat.shiftRight_succ_inside | Init.Data.Nat.Lemmas | ∀ (m n : ℕ), m >>> (n + 1) = (m / 2) >>> n | Shift right on successor with division moved inside. | true |
CategoryTheory.Limits.IsColimit.descCoconeMorphism.eq_1 | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {t : CategoryTheory.Limits.Cocone F} (h : CategoryTheory.Limits.IsColimit t)
(s : CategoryTheory.Limits.Cocone F), h.descCoconeMorphism s = { hom := h.desc s, w :=... | null | true |
Std.DTreeMap.getKeyD_maxKeyD | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp],
t.isEmpty = false → ∀ {fallback fallback' : α}, t.getKeyD (t.maxKeyD fallback) fallback' = t.maxKeyD fallback | null | true |
_private.Mathlib.Computability.DFA.0.DFA.accepts_reindex._simp_1_1 | Mathlib.Computability.DFA | ∀ {α : Type u} {σ : Type v} (M : DFA α σ) {x : List α}, (x ∈ M.accepts) = (M.eval x ∈ M.accept) | null | false |
DirectSum.id._proof_5 | Mathlib.Algebra.DirectSum.Basic | ∀ (M : Type u_2) (ι : Type u_1) [inst : AddCommMonoid M] [inst_1 : Unique ι] (x : DirectSum ι fun x => M),
(DirectSum.of (fun x => M) default) ((DirectSum.toAddMonoid fun x => AddMonoidHom.id M) x) = x | null | false |
Valuation.IsRankOneDiscrete.generator_zpowers_eq_valueGroup | Mathlib.RingTheory.Valuation.Discrete.Basic | ∀ {Γ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ] {A : Type u_2} [inst_1 : Ring A] (v : Valuation A Γ)
[inst_2 : v.IsRankOneDiscrete], Subgroup.zpowers (Valuation.IsRankOneDiscrete.generator v) = (↑v).valueGroup | null | true |
Std.Http.Status.isError | Std.Http.Data.Status | Std.Http.Status → Bool | Checks if the status code indicates an error (either client error 4xx or server error 5xx).
Reference: https://httpwg.org/specs/rfc9110.html#status.codes
| true |
CategoryTheory.AbelianOfAdjunction.hasKernels | Mathlib.CategoryTheory.Abelian.Transfer | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D)
(G : CategoryTheory.Functor D C) [G.PreservesZeroMorphisms] [CategoryTheory.Limits.Pres... | No point making this an instance, as it requires `i`. | true |
equicontinuous_iInf_rng | Mathlib.Topology.UniformSpace.Equicontinuity | ∀ {ι : Type u_1} {κ : Type u_2} {X : Type u_3} {α' : Type u_7} [tX : TopologicalSpace X] {u : κ → UniformSpace α'}
{F : ι → X → α'}, Equicontinuous F ↔ ∀ (k : κ), Equicontinuous F | null | true |
Lean.ModuleIdx.toNat | Lean.Environment | Lean.ModuleIdx → ℕ | null | true |
_private.Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet.0.«term_~ᵤ_» | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | Lean.TrailingParserDescr | null | true |
CategoryTheory.Lax.OplaxTrans.Modification.mk.inj | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u₁} {inst : CategoryTheory.Bicategory B} {C : Type u₂} {inst_1 : CategoryTheory.Bicategory C}
{F G : CategoryTheory.LaxFunctor B C} {η θ : F ⟶ G} {app : (a : B) → η.app a ⟶ θ.app a}
{naturality :
autoParam
(∀ {a b : B} (f : a ⟶ b),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bic... | null | true |
LieDerivation.ofGradingSum._proof_3 | Mathlib.Algebra.Lie.Graded | ∀ {ι : Type u_3} {R : Type u_1} {L : Type u_2} [inst : DecidableEq ι] [inst_1 : AddCommMonoid ι] [inst_2 : CommRing R]
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] (ℒ : ι → Submodule R L) [inst_5 : GradedLieAlgebra ℒ],
LieModule R (DirectSum ι fun i => ↥(ℒ i)) (DirectSum ι fun k => ↥(ℒ k)) | null | false |
NonUnitalSubring.mem_inf._simp_1 | Mathlib.RingTheory.NonUnitalSubring.Basic | ∀ {R : Type u} [inst : NonUnitalNonAssocRing R] {p p' : NonUnitalSubring R} {x : R}, (x ∈ p ⊓ p') = (x ∈ p ∧ x ∈ p') | null | false |
Std.ExtDHashMap.Const.getKey?_alter_self | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {f : Option β → Option β},
(Std.ExtDHashMap.Const.alter m k f).getKey? k =
if (f (Std.ExtDHashMap.Const.get? m k)).isSome = true then some k else none | null | true |
Vector.findSome?_singleton | Init.Data.Vector.Find | ∀ {α : Type u_1} {β : Type u_2} {a : α} {f : α → Option β}, Vector.findSome? f #v[a] = f a | null | true |
conditionallyCompleteLatticeOfsSup._proof_3 | Mathlib.Order.ConditionallyCompleteLattice.Defs | ∀ (α : Type u_1) [H1 : PartialOrder α] [H2 : SupSet α] (bddAbove_pair : ∀ (a b : α), BddAbove {a, b})
(bddBelow_pair : ∀ (a b : α), BddBelow {a, b})
(isLUB_sSup : ∀ (s : Set α), BddAbove s → s.Nonempty → IsLUB s (sSup s)) (x : Set α),
x.Nonempty → BddBelow x → IsGLB x (sSup (lowerBounds x)) | null | false |
Plausible.Testable.ctorIdx | Plausible.Testable | {p : Prop} → Plausible.Testable p → ℕ | null | false |
Submodule.moduleSet._proof_6 | Mathlib.Algebra.Algebra.Operations | ∀ (R : Type u_2) [inst : CommSemiring R] (A : Type u_1) [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
(P : Submodule R A), 0 • P = 0 | null | false |
DomAddAct.instVAddCommClassForall | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} {β : Type u_2} {α : Type u_3} {N : Type u_4} [inst : VAdd M α] [inst_1 : VAdd N β],
VAddCommClass Mᵈᵃᵃ N (α → β) | null | true |
CategoryTheory.CommSq.LiftStruct.l | Mathlib.CategoryTheory.CommSq | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{A B X Y : C} →
{f : A ⟶ X} →
{i : A ⟶ B} → {p : X ⟶ Y} → {g : B ⟶ Y} → {sq : CategoryTheory.CommSq f i p g} → sq.LiftStruct → (B ⟶ X) | The lift. | true |
Mathlib.Tactic._aux_Mathlib_Tactic_DefEqTransformations___elabRules_Mathlib_Tactic_tacticReduce___1 | Mathlib.Tactic.DefEqTransformations | Lean.Elab.Tactic.Tactic | `reduce at loc` completely reduces the given location.
This also exists as a `conv`-mode tactic.
This does the same transformation as the `#reduce` command.
| false |
Lean.PrettyPrinter.Delaborator.delabAppExplicitCore | Lean.PrettyPrinter.Delaborator.Builtins | Bool →
ℕ →
(Bool → Lean.PrettyPrinter.Delaborator.Delab) →
Array Lean.PrettyPrinter.Delaborator.ParamKind → Lean.PrettyPrinter.Delaborator.Delab | Delaborates a function application in explicit mode.
* If `insertExplicit` is true, then ensures the head syntax is wrapped with `@`.
* If `fieldNotation` is true, then allows the application to be pretty printed using field notation.
Field notation will not be used when `insertExplicit` is true.
| true |
Polynomial.card_support_trinomial | Mathlib.Algebra.Polynomial.Coeff | ∀ {R : Type u} [inst : Semiring R] {k m n : ℕ},
k < m →
m < n →
∀ {x y z : R},
x ≠ 0 →
y ≠ 0 →
z ≠ 0 →
(Polynomial.C x * Polynomial.X ^ k + Polynomial.C y * Polynomial.X ^ m +
Polynomial.C z * Polynomial.X ^ n).support.card =
... | null | true |
exists_eq_smul_of_parallel | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {p₁ p₂ p₃ p₄ p₅ p₆ : P},
p₂ ∉ line[k, p₁, p₃] →
line[k, p₁, p₂].Parallel line[k, p₄, p₅] →
line[k, p₅, p₆].direction ≤ line[k, p₂, p₃].direction →
line[k,... | Given two triples of non-collinear points, if the lines determined by corresponding pairs of
points are parallel, then the vectors between corresponding pairs of points are all related by the
same nonzero scale factor. (The formal statement is slightly more general.) | true |
Function.support_comp_eq_preimage | Mathlib.Algebra.Notation.Support | ∀ {ι : Type u_1} {κ : Type u_2} {M : Type u_3} [inst : Zero M] (g : κ → M) (f : ι → κ),
Function.support (g ∘ f) = f ⁻¹' Function.support g | null | true |
Nat.cast_mem_Ioo_iff | Mathlib.Order.Interval.Finset.Floor | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : LinearOrder α] [inst_2 : FloorSemiring α] {a b : α} {n : ℕ},
0 ≤ a → (↑n ∈ Set.Ioo a b ↔ n ∈ Finset.Ioo ⌊a⌋₊ ⌈b⌉₊) | null | true |
MeasureTheory.L1.integral_eq' | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_1} {E : Type u_2} (𝕜 : Type u_4) [inst : NormedAddCommGroup E] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} [inst_1 : NormedSpace ℝ E] [inst_2 : NormedRing 𝕜] [inst_3 : Module 𝕜 E]
[inst_4 : IsBoundedSMul 𝕜 E] [inst_5 : SMulCommClass ℝ 𝕜 E] [inst_6 : CompleteSpace E]
(f : ↥(MeasureTheo... | null | true |
SSet.PtSimplex.MulStruct.op_map | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {X : SSet} {n : ℕ} {x : X.obj (Opposite.op { len := 0 })} {f g fg : X.PtSimplex n x} {i : Fin n}
(h : f.MulStruct g fg i) {j : Fin n} (hij : autoParam (i.rev = j) SSet.PtSimplex.MulStruct.op._auto_1),
(h.op hij).map = SSet.yonedaEquiv.symm (SSet.opObjEquiv.symm (SSet.yonedaEquiv h.map)) | null | true |
RegularExpression.matches'_zero | Mathlib.Computability.RegularExpressions | ∀ {α : Type u_1}, RegularExpression.matches' 0 = 0 | null | true |
SheafOfModules.Hom._sizeOf_1 | Mathlib.Algebra.Category.ModuleCat.Sheaf | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} → {X Y : SheafOfModules R} → [SizeOf C] → X.Hom Y → ℕ | null | false |
_private.Mathlib.RingTheory.Frobenius.0.AlgHom.IsArithFrobAt.isArithFrobAt_localize._simp_1_3 | Mathlib.RingTheory.Frobenius | ∀ {R : Type u} [inst : Ring R] {I : Ideal R} {a : R} [inst_1 : I.IsTwoSided], (a ∈ I) = ((Ideal.Quotient.mk I) a = 0) | null | false |
CategoryTheory.Pseudofunctor.hasCoeToOplax | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] → Coe (CategoryTheory.Pseudofunctor B C) (CategoryTheory.OplaxFunctor B C) | null | true |
AddMonCat.coe_of | Mathlib.Algebra.Category.MonCat.Basic | ∀ (M : Type u) [inst : AddMonoid M], ↑↧M = M | null | true |
_private.Lean.Environment.0.Lean.mkIRData | Lean.Environment | Lean.Environment → Lean.ModuleData | null | true |
_private.Std.Data.DHashMap.Internal.WF.0.Std.Internal.List.alterKey.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] (k : α) (f : Option (β k) → Option (β k))
(l : List ((a : α) × β a)),
Std.Internal.List.alterKey k f l =
match f (Std.Internal.List.getValueCast? k l) with
| none => Std.Internal.List.eraseKey k l
| some v => Std.Internal.List.insertE... | null | true |
LocallyFiniteOrder.ofOrderIsoClass | Mathlib.Order.Interval.Finset.Defs | {F : Type u_3} →
{M : Type u_4} →
{N : Type u_5} →
[inst : Preorder M] →
[inst_1 : Preorder N] →
[inst_2 : EquivLike F M N] → [OrderIsoClass F M N] → F → [LocallyFiniteOrder N] → LocallyFiniteOrder M | A `LocallyFiniteOrder` can be transferred across an order isomorphism. | true |
_private.Mathlib.Data.Finset.Basic.0.Multiset.toFinset_nonempty._simp_1_1 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} {s : Finset α}, s.Nonempty = (s ≠ ∅) | null | false |
CategoryTheory.Limits.reflectsCofilteredLimitsOfSize_of_univLE | Mathlib.CategoryTheory.Limits.Preserves.Filtered | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [UnivLE.{w, w'}] [UnivLE.{w₂, w₂'}]
[CategoryTheory.Limits.ReflectsCofilteredLimitsOfSize.{w', w₂', v₁, v₂, u₁, u₂} F],
CategoryTheory.Limits.ReflectsCofilteredL... | A functor reflecting larger cofiltered limits also reflects smaller cofiltered limits. | true |
ContIntertwiningMap.mapInvariants | Mathlib.RepresentationTheory.Continuous.Basic | {R : Type u_1} →
{G : Type u_2} →
{V : Type u_3} →
{W : Type u_4} →
[inst : Monoid G] →
[inst_1 : Ring R] →
[inst_2 : AddCommGroup V] →
[inst_3 : TopologicalSpace V] →
[inst_4 : IsTopologicalAddGroup V] →
[inst_5 : Module R V] →
... | The map induced on `G`-invariant elements by a continuous intertwining map. | true |
CategoryTheory.ShortComplex.homologyFunctorOpNatIso._proof_1 | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[CategoryTheory.CategoryWithHomology C] (S : (CategoryTheory.ShortComplex C)ᵒᵖ), (Opposite.unop S).op.HasHomology | null | false |
_private.Mathlib.RingTheory.Invariant.Galois.0.instSMulDistribClassAlgEquiv._simp_1 | Mathlib.RingTheory.Invariant.Galois | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [IsRightCancelMulZero M₀] {a b c : M₀}, (a * c = b * c) = (a = b ∨ c = 0) | null | false |
SimpleGraph.induceHom | Mathlib.Combinatorics.SimpleGraph.Maps | {V : Type u_1} →
{W : Type u_2} →
{G : SimpleGraph V} →
{G' : SimpleGraph W} →
{s : Set V} →
{t : Set W} → (φ : G →g G') → Set.MapsTo (⇑φ) s t → SimpleGraph.induce s G →g SimpleGraph.induce t G' | The restriction of a morphism of graphs to induced subgraphs. | true |
Lean.getCasesInfo? | Lean.Meta.CasesInfo | Lean.Name → Lean.CoreM (Option Lean.CasesInfo) | null | true |
_private.Mathlib.NumberTheory.LSeries.MellinEqDirichlet.0.hasSum_mellin_pi_mul_sq'._simp_1_5 | Mathlib.NumberTheory.LSeries.MellinEqDirichlet | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | null | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms.0.CategoryTheory.Limits.HasZeroMorphisms.ext_aux | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (I J : CategoryTheory.Limits.HasZeroMorphisms C),
(∀ (X Y : C), Zero.zero = Zero.zero) → I = J | This lemma will be immediately superseded by `ext`, below. | true |
Lean.Linter.LinterSetsState | Lean.Linter.Init | Type | State of `linterSetsExt`.
`merged` is the queryable union of all sources (builtins folded in at env creation,
imported entries from oleans, and locally added entries). `localEntries` tracks entries
added in the current module so they can be exported into the olean.
| true |
Matrix.IsPrimitive.mk._flat_ctor | Mathlib.LinearAlgebra.Matrix.Irreducible.Defs | ∀ {n : Type u_1} {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : Fintype n] [inst_3 : DecidableEq n]
{A : Matrix n n R}, (∀ (i j : n), 0 ≤ A i j) → (∃ k > 0, ∀ (i j : n), 0 < (A ^ k) i j) → A.IsPrimitive | null | false |
Lean.Compiler.LCNF.FunDecl.mk.noConfusion | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{P : Sort u} →
{fvarId : Lean.FVarId} →
{binderName : Lean.Name} →
{params : Array (Lean.Compiler.LCNF.Param pu)} →
{type : Lean.Expr} →
{value : Lean.Compiler.LCNF.Code pu} →
{fvarId' : Lean.FVarId} →
{binderName... | null | false |
_private.Mathlib.GroupTheory.FreeGroup.Basic.0.FreeGroup.equivIntOfUnique._simp_2 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | null | false |
Filter.Germ.instMonoid.eq_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {M : Type u_5} [inst : Monoid M],
Filter.Germ.instMonoid =
{ toOne := Filter.Germ.instOne, toMul := Filter.Germ.instSemigroup.toMul, mul_assoc := ⋯, one_mul := ⋯,
mul_one := ⋯, npow := fun n a => a ^ n, npow_zero := ⋯, npow_succ := ⋯ } | null | true |
CategoryTheory.Distributive._aux_Mathlib_CategoryTheory_Distributive_Monoidal___unexpand_CategoryTheory_leftDistrib_1 | Mathlib.CategoryTheory.Distributive.Monoidal | Lean.PrettyPrinter.Unexpander | null | false |
CategoryTheory.LaxBraidedFunctor.comp_hom | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u₂} [inst_3 : CategoryTheory.Category.{v₂, u₂} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D]
{F G H : Categor... | null | true |
Aesop.evalAesop | Aesop.Main | Lean.Elab.Tactic.Tactic | null | true |
MeasureTheory.measure_sdiff_le_iff_le_add | Mathlib.MeasureTheory.Measure.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
MeasureTheory.NullMeasurableSet s μ → s ⊆ t → μ s ≠ ⊤ → ∀ {ε : ENNReal}, μ (t \ s) ≤ ε ↔ μ t ≤ μ s + ε | null | true |
CategoryTheory.kernelCokernelCompSequence.snakeInput_L₁_g | Mathlib.CategoryTheory.Abelian.DiagramLemmas.KernelCokernelComp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X Y Z : C} (f : X ⟶ Y)
(g : Y ⟶ Z), (CategoryTheory.kernelCokernelCompSequence.snakeInput f g).L₁.g = CategoryTheory.Limits.biprod.snd | null | true |
WCovBy.Ioo_eq | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a ⩿ b → Set.Ioo a b = ∅ | null | true |
MonCat.HasLimits.limitConeIsLimit._proof_2 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] (F : CategoryTheory.Functor J MonCat)
(s : CategoryTheory.Limits.Cone F) (v : ((CategoryTheory.forget MonCat).mapCone s).pt) {j j' : J} (f : j ⟶ j'),
(CategoryTheory.ConcreteCategory.hom
(CategoryTheory.CategoryStruct.comp (((CategoryTheory.forg... | null | false |
Std.Time.TimeZone.TransitionSpec.julian0 | Std.Time.Zoned.RecurringRule | Std.Time.Internal.Bounded.LE 0 365 → Std.Time.TimeZone.TransitionSpec | `n` form: zero-based day 0–365 (Feb 29 counted in leap years).
| true |
Lean.DeclarationRanges.mk.inj | Lean.Data.DeclarationRange | ∀ {range selectionRange range_1 selectionRange_1 : Lean.DeclarationRange},
{ range := range, selectionRange := selectionRange } = { range := range_1, selectionRange := selectionRange_1 } →
range = range_1 ∧ selectionRange = selectionRange_1 | null | true |
ENNReal.le_toNNReal_of_coe_le | Mathlib.Basic.ENNReal.Real | ∀ {a : ENNReal} {p : NNReal}, ↑p ≤ a → a ≠ ⊤ → p ≤ a.toNNReal | null | true |
_private.Mathlib.RingTheory.Ideal.Operations.0.Ideal.isCoprime_biInf._simp_1_1 | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : CommSemiring R] {I J : Ideal R}, IsCoprime I J = (I + J = 1) | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.reduceBEq._regBuiltin.BitVec.reduceBEq.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.2263489043._hygCtx._hyg.30 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | null | false |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.u₁ | Mathlib.NumberTheory.FLT.Three | {K : Type u_1} →
[inst : Field K] →
{ζ : K} →
{hζ : IsPrimitiveRoot ζ 3} →
FermatLastTheoremForThreeGen.Solution✝ hζ →
[inst_1 : NumberField K] → [IsCyclotomicExtension {3} ℚ K] → (NumberField.RingOfIntegers K)ˣ | null | true |
Int.dvd_negSucc._simp_1 | Init.Data.Int.DivMod.Lemmas | ∀ {a : ℤ} {b : ℕ}, (a ∣ Int.negSucc b) = (a ∣ ↑(b + 1)) | null | false |
_private.ProofWidgets.Data.Html.0.ProofWidgets.Jsx.transformTag.match_10 | ProofWidgets.Data.Html | (motive : Lean.Ident × Lean.Term → Sort u_1) →
(x : Lean.Ident × Lean.Term) → ((k : Lean.Ident) → (v : Lean.Term) → motive (k, v)) → motive x | null | false |
_private.Mathlib.SetTheory.Cardinal.Basic.0.Cardinal.range_natCast._simp_1_4 | Mathlib.SetTheory.Cardinal.Basic | ∀ {c : Cardinal.{u_1}}, (c < Cardinal.aleph0) = ∃ n, c = ↑n | null | false |
CategoryTheory.Prod.braiding | Mathlib.CategoryTheory.Products.Basic | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(D : Type u₂) → [inst_1 : CategoryTheory.Category.{v₂, u₂} D] → C × D ≌ D × C | The equivalence, given by swapping factors, between `C × D` and `D × C`.
| true |
SSet.Subcomplex.existsN | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplicesSubcomplex | ∀ {X : SSet} {n : ℕ} (s : X.obj (Opposite.op { len := n })) {A : X.Subcomplex},
s ∉ A.obj (Opposite.op { len := n }) →
∃ x f, CategoryTheory.Epi f ∧ (CategoryTheory.ConcreteCategory.hom (X.map f.op)) x.simplex = s | null | true |
_private.Mathlib.Data.Finset.Lattice.Fold.0.Finset.lt_sup_iff.match_1_5 | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {ι : Type u_1} [inst : LinearOrder α] {s : Finset ι} {f : ι → α} {a : α}
(motive : (∃ b ∈ s, a < f b) → Prop) (x : ∃ b ∈ s, a < f b),
(∀ (b : ι) (hb : b ∈ s) (hlt : a < f b), motive ⋯) → motive x | null | false |
Lean.Elab.ConfigEval.EvalConfigItem.mk.injEq | Lean.Elab.ConfigEval.Types | ∀ {α : Type} (set set_1 : α → Lean.Elab.ConfigEval.ConfigItem → Lean.Elab.TermElabM α),
({ set := set } = { set := set_1 }) = (set = set_1) | null | true |
_private.Mathlib.Analysis.Normed.Unbundled.FiniteExtension.0.Module.Basis.norm_nonneg._simp_1_5 | Mathlib.Analysis.Normed.Unbundled.FiniteExtension | ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (∃ x, b) = b | null | false |
Multiset.toFinsupp._proof_2 | Mathlib.Data.Finsupp.Multiset | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Multiset α),
(fun f => Finsupp.toMultiset f)
((fun s => { support := s.toFinset, toFun := fun a => Multiset.count a s, mem_support_toFun := ⋯ }) s) =
s | null | false |
CategoryTheory.Pretriangulated.Opposite.instHasShiftOppositeInt._proof_11 | Mathlib.CategoryTheory.Triangulated.Opposite.Basic | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ],
autoParam
(∀ (X : CategoryTheory.Discrete ℤ),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor
((CategoryTheory.Pretriangulated.Opposite.instHasShiftOppositeInt._aux_1 C).obj X)).hom =
... | null | false |
isSimplyConnected_smul_set₀_iff._simp_1 | Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected | ∀ {X : Type u_1} [inst : TopologicalSpace X] {G : Type u_3} [inst_1 : GroupWithZero G] [inst_2 : MulAction G X]
[ContinuousConstSMul G X] {c : G} {s : Set X}, c ≠ 0 → IsSimplyConnected (c • s) = IsSimplyConnected s | null | false |
_private.Mathlib.RingTheory.PowerSeries.Basic.0.Polynomial.coe_injective._simp_1_1 | Mathlib.RingTheory.PowerSeries.Basic | ∀ {R : Type u_1} [inst : Semiring R] (φ : Polynomial R) (n : ℕ), φ.coeff n = (PowerSeries.coeff n) ↑φ | null | false |
IsCornerFree.eq_1 | Mathlib.Combinatorics.Additive.Corner.Roth | ∀ {G : Type u_1} [inst : AddCommMonoid G] (A : Set (G × G)),
IsCornerFree A = ∀ ⦃x₁ y₁ x₂ y₂ : G⦄, IsCorner A x₁ y₁ x₂ y₂ → x₁ = x₂ | null | true |
QuadraticAlgebra.mk_mul_mk | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : Mul R] [inst_1 : Add R] (x1 y1 x2 y2 : R),
{ re := x1, im := y1 } * { re := x2, im := y2 } =
{ re := x1 * x2 + a * y1 * y2, im := x1 * y2 + y1 * x2 + b * y1 * y2 } | null | true |
Int.sub_mul_bmod_self_right | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ) (c : ℕ), (a - b * ↑c).bmod c = a.bmod c | null | true |
Mathlib.Tactic.ITauto.Proof.noConfusion | Mathlib.Tactic.ITauto | {P : Sort u} → {t t' : Mathlib.Tactic.ITauto.Proof} → t = t' → Mathlib.Tactic.ITauto.Proof.noConfusionType P t t' | null | false |
Lean.Elab.evalSyntaxConstant | Lean.Elab.Util | Lean.Environment → Lean.Options → Lean.Name → ExceptT String Id Lean.Syntax | null | true |
Subgroup.instEncodableSubtypeMulOppositeMemOp.eq_1 | Mathlib.Algebra.Group.Subgroup.MulOppositeLemmas | ∀ {G : Type u_2} [inst : Group G] (H : Subgroup G) [inst_1 : Encodable ↥H],
H.instEncodableSubtypeMulOppositeMemOp = Encodable.ofEquiv (↥H) H.equivOp.symm | null | true |
CategoryTheory.ShortComplex.LeftHomologyData.ofZeros_H | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) (hf : S.f = 0) (hg : S.g = 0),
(CategoryTheory.ShortComplex.LeftHomologyData.ofZeros S hf hg).H = S.X₂ | null | true |
MeasureTheory.Filtration.limitProcess_neg | Mathlib.Probability.Process.LimitProcess | ∀ {ι : Type u_1} {Ω : Type u_2} {E : Type u_3} [inst : Preorder ι] {mΩ : MeasurableSpace Ω}
[inst_1 : TopologicalSpace E] {P : MeasureTheory.Measure Ω} {𝓕 : MeasureTheory.Filtration ι mΩ} [IsDirectedOrder ι]
[Nonempty ι] [T2Space E] [inst_5 : AddGroup E] [ContinuousNeg E] (X : ι → Ω → E),
MeasureTheory.Filtratio... | null | true |
IsCoprime.of_mul_left_left | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u} [inst : CommSemiring R] {x y z : R}, IsCoprime (x * y) z → IsCoprime x z | null | true |
Std.DHashMap.Internal.Raw.size_eq_length | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β},
Std.DHashMap.Internal.Raw.WFImp m → m.size = (Std.DHashMap.Internal.toListModel m.buckets).length | null | true |
Lean.Grind.GrobnerConfig.qlia._inherited_default | Init.Grind.Config | Bool | null | false |
Representation.TensorProduct.comm_symm | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : CommSemiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : Module A V] [inst_5 : Module A W]
(ρ : Representation A G V) (σ : Representation A G W),
(Representation.TensorProduct.comm σ ρ).symm = Represen... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.