name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Congruent.comp_left_iff | Mathlib.Topology.MetricSpace.Congruence | ∀ {ι : Type u_1} {P₁ : Type u_3} {P₂ : Type u_4} {P₃ : Type u_5} {v₁ : ι → P₁} {v₂ : ι → P₂}
[inst : PseudoEMetricSpace P₁] [inst_1 : PseudoEMetricSpace P₂] [inst_2 : PseudoEMetricSpace P₃] {f : P₁ → P₃},
Isometry f → (Congruent (f ∘ v₁) v₂ ↔ Congruent v₁ v₂) | true |
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.MvPolynomial.universalFactorizationMapPresentation_jacobiMatrix._proof_1_5 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ (R : Type u_1) [inst : CommRing R] (m k : ℕ) (i : Fin m) (i_1 : Fin k),
(if m + ↑i_1 < ↑i then 0
else
if h : m + ↑i_1 - ↑i < k then MvPolynomial.X (Sum.inr ⟨m + ↑i_1 - ↑i, ⋯⟩)
else if m + ↑i_1 - ↑i = k then 1 else 0) =
if ↑i ≤ m + ↑i_1 ∧ m + ↑i_1 ≤ ↑i + k then
if h : m + ↑i_1 - ↑i < k then MvPolynomial.X (Sum.inr ⟨m + ↑i_1 - ↑i, ⋯⟩) else if m + ↑i_1 - ↑i = k then 1 else 0
else 0 | false |
Lean.IR.EmitC.Context.mk.inj | Lean.Compiler.IR.EmitC | ∀ {env : Lean.Environment} {modName : Lean.Name} {jpMap : Lean.IR.JPParamsMap} {mainFn : Lean.IR.FunId}
{mainParams : Array Lean.IR.Param} {env_1 : Lean.Environment} {modName_1 : Lean.Name} {jpMap_1 : Lean.IR.JPParamsMap}
{mainFn_1 : Lean.IR.FunId} {mainParams_1 : Array Lean.IR.Param},
{ env := env, modName := modName, jpMap := jpMap, mainFn := mainFn, mainParams := mainParams } =
{ env := env_1, modName := modName_1, jpMap := jpMap_1, mainFn := mainFn_1, mainParams := mainParams_1 } →
env = env_1 ∧ modName = modName_1 ∧ jpMap = jpMap_1 ∧ mainFn = mainFn_1 ∧ mainParams = mainParams_1 | true |
CategoryTheory.Limits.Fork.IsLimit.mk._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f g : X ⟶ Y}
(t : CategoryTheory.Limits.Fork f g) (lift : (s : CategoryTheory.Limits.Fork f g) → s.pt ⟶ t.pt),
(∀ (s : CategoryTheory.Limits.Fork f g) (m : s.pt ⟶ t.pt),
CategoryTheory.CategoryStruct.comp m t.ι = s.ι → m = lift s) →
∀ (s : CategoryTheory.Limits.Cone (CategoryTheory.Limits.parallelPair f g)) (m : s.pt ⟶ t.pt),
(∀ (j : CategoryTheory.Limits.WalkingParallelPair),
CategoryTheory.CategoryStruct.comp m (t.π.app j) = s.π.app j) →
m = lift s | false |
CategoryTheory.GrothendieckTopology.Cover.Arrow.fromMiddleHom | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{X : C} → {S : J.Cover X} → {T : (I : S.Arrow) → J.Cover I.Y} → (I : (S.bind T).Arrow) → I.middle ⟶ X | true |
_private.Batteries.Data.BitVec.Lemmas.0.BitVec.getMsbD_ofFnLE._proof_1_2 | Batteries.Data.BitVec.Lemmas | ∀ {n : ℕ} (i : ℕ), n - (i + 1) + 1 ≤ n → n - (i + 1) < n | false |
_private.Mathlib.Tactic.IrreducibleDef.0.Lean.Elab.Command._aux_Mathlib_Tactic_IrreducibleDef___elabRules__private_Mathlib_Tactic_IrreducibleDef_0_Lean_Elab_Command_commandStop_at_first_error___1.match_1 | Mathlib.Tactic.IrreducibleDef | (motive : Option (Array (Lean.TSyntax `command)) → Sort u_1) →
(x : Option (Array (Lean.TSyntax `command))) →
((cmds : Array (Lean.TSyntax `command)) → motive (some cmds)) → (Unit → motive none) → motive x | false |
NumberField.Units.instFiniteIntAdditiveQuotientUnitsRingOfIntegersSubgroupTorsion | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ (K : Type u_1) [inst : Field K] [NumberField K],
Module.Finite ℤ (Additive ((NumberField.RingOfIntegers K)ˣ ⧸ NumberField.Units.torsion K)) | true |
MonomialOrder.degree_neg | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommRing R] {f : MvPolynomial σ R},
m.degree (-f) = m.degree f | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.Extension.getEMatchTheoremsForNamespace.match_4 | Lean.Meta.Tactic.Grind.EMatchTheorem | (motive : Option (Lean.PArray Lean.Meta.Grind.Entry) → Sort u_1) →
(x : Option (Lean.PArray Lean.Meta.Grind.Entry)) →
(Unit → motive none) → ((entries : Lean.PArray Lean.Meta.Grind.Entry) → motive (some entries)) → motive x | false |
_private.Mathlib.RingTheory.NoetherNormalization.0.NoetherNormalization.degreeOf_t_ne_of_ne | Mathlib.RingTheory.NoetherNormalization | ∀ {k : Type u_1} [inst : Field k] {n : ℕ} (f : MvPolynomial (Fin (n + 1)) k) (v w : Fin (n + 1) →₀ ℕ),
v ∈ f.support →
w ∈ f.support →
v ≠ w →
MvPolynomial.degreeOf 0 ((NoetherNormalization.T✝ f) ((MvPolynomial.monomial v) (MvPolynomial.coeff v f))) ≠
MvPolynomial.degreeOf 0 ((NoetherNormalization.T✝¹ f) ((MvPolynomial.monomial w) (MvPolynomial.coeff w f))) | true |
lift_rank_range_of_injective | Mathlib.LinearAlgebra.Dimension.Basic | ∀ {R : Type u} {M : Type v} {M' : Type v'} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (f : M →ₗ[R] M'),
Function.Injective ⇑f → Cardinal.lift.{v, v'} (Module.rank R ↥f.range) = Cardinal.lift.{v', v} (Module.rank R M) | true |
Lean.Meta.TacticResultCNM.modified.elim | Lean.Meta.Tactic.Util | {motive : Lean.Meta.TacticResultCNM → Sort u} →
(t : Lean.Meta.TacticResultCNM) →
t.ctorIdx = 2 → ((mvarId : Lean.MVarId) → motive (Lean.Meta.TacticResultCNM.modified mvarId)) → motive t | false |
Std.Do.ExceptT.instWPMonad._proof_1 | Std.Do.WP.Monad | ∀ {m : Type u_1 → Type u_2} {ps : Std.Do.PostShape} {ε : Type u_1} [inst : Monad m] [Std.Do.WPMonad m ps],
LawfulMonad (ExceptT ε m) | false |
Lean.Lsp.FileSystemWatcher.mk.inj | Lean.Data.Lsp.Workspace | ∀ {globPattern : String} {kind? : Option ℕ} {globPattern_1 : String} {kind?_1 : Option ℕ},
{ globPattern := globPattern, kind? := kind? } = { globPattern := globPattern_1, kind? := kind?_1 } →
globPattern = globPattern_1 ∧ kind? = kind?_1 | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.foldrM_eq_foldrM_toList._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
List.cons_eq_cons | Init.Data.List.Lemmas | ∀ {α : Type u_1} {a b : α} {l l' : List α}, a :: l = b :: l' ↔ a = b ∧ l = l' | true |
Set.Definable.compl._simp_1 | Mathlib.ModelTheory.Definability | ∀ {M : Type w} {A : Set M} {L : FirstOrder.Language} [inst : L.Structure M] {α : Type u₁} {s : Set (α → M)},
A.Definable L s → A.Definable L sᶜ = True | false |
ONote.repr.eq_def | Mathlib.SetTheory.Ordinal.Notation | ∀ (x : ONote),
x.repr =
match x with
| ONote.zero => 0
| e.oadd n a => Ordinal.omega0 ^ e.repr * ↑↑n + a.repr | true |
CategoryTheory.Limits.WidePushoutShape.mkCocone_ι_app | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor (CategoryTheory.Limits.WidePushoutShape J) C} {X : C} (f : F.obj none ⟶ X)
(ι : (j : J) → F.obj (some j) ⟶ X)
(w :
∀ (j : J), CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Limits.WidePushoutShape.Hom.init j)) (ι j) = f)
(j : CategoryTheory.Limits.WidePushoutShape J),
(CategoryTheory.Limits.WidePushoutShape.mkCocone f ι w).ι.app j =
match j with
| none => f
| some j => ι j | true |
Mathlib.Tactic.Widget.StringDiagram.Kind.toCtorIdx | Mathlib.Tactic.Widget.StringDiagram | Mathlib.Tactic.Widget.StringDiagram.Kind → ℕ | false |
String.Slice.Pos.byte_copy | Init.Data.String.Basic | ∀ {s : String.Slice} {pos : s.Pos} (h : pos.copy ≠ s.copy.endPos), pos.copy.byte h = pos.byte ⋯ | true |
DFA.reindex | Mathlib.Computability.DFA | {α : Type u} → {σ : Type v} → {σ' : Type u_2} → σ ≃ σ' → DFA α σ ≃ DFA α σ' | true |
LieRinehartRing.recOn | Mathlib.Algebra.LieRinehartAlgebra.Defs | {A : Type u_1} →
{L : Type u_2} →
[inst : CommRing A] →
[inst_1 : LieRing L] →
[inst_2 : Module A L] →
[inst_3 : LieRingModule L A] →
{motive : LieRinehartRing A L → Sort u} →
(t : LieRinehartRing A L) →
((lie_smul_eq_mul' : ∀ (a b : A) (x : L), ⁅a • x, b⁆ = a * ⁅x, b⁆) →
(leibniz_mul_right' : ∀ (x : L) (a b : A), ⁅x, a * b⁆ = a • ⁅x, b⁆ + ⁅x, a⁆ * b) →
(leibniz_smul_right' : ∀ (x y : L) (a : A), ⁅x, a • y⁆ = a • ⁅x, y⁆ + ⁅x, a⁆ • y) → motive ⋯) →
motive t | false |
nndist_pi_def | Mathlib.Topology.MetricSpace.Pseudo.Pi | ∀ {β : Type u_2} {X : β → Type u_3} [inst : Fintype β] [inst_1 : (b : β) → PseudoMetricSpace (X b)]
(f g : (b : β) → X b), nndist f g = Finset.univ.sup fun b => nndist (f b) (g b) | true |
Std.CloseableChannel.Error._sizeOf_inst | Std.Sync.Channel | SizeOf Std.CloseableChannel.Error | false |
FractionalIdeal.isPrincipal_iff | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
[inst_3 : IsLocalization S P] (I : FractionalIdeal S P), (↑I).IsPrincipal ↔ ∃ x, I = FractionalIdeal.spanSingleton S x | true |
Std.TreeSet.Raw.Equiv.forM_eq | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet.Raw α cmp} {m : Type w → Type w'} [Std.TransCmp cmp]
[inst : Monad m] [LawfulMonad m] {f : α → m PUnit.{w + 1}}, t₁.WF → t₂.WF → t₁.Equiv t₂ → forM t₁ f = forM t₂ f | true |
_private.Lean.Compiler.IR.LLVMBindings.0.LLVM.Visibility.mk.sizeOf_spec | Lean.Compiler.IR.LLVMBindings | ∀ (val : UInt64), sizeOf { val := val } = 1 + sizeOf val | true |
Dynamics.coverEntropyEntourage_univ | Mathlib.Dynamics.TopologicalEntropy.CoverEntropy | ∀ {X : Type u_1} {F : Set X} (T : X → X), F.Nonempty → Dynamics.coverEntropyEntourage T F Set.univ = 0 | true |
AlgebraicGeometry.instIsMultiplicativeSchemeIsSchemeTheoreticallyDominant | Mathlib.AlgebraicGeometry.Morphisms.SchemeTheoreticallyDominant | CategoryTheory.MorphismProperty.IsMultiplicative @AlgebraicGeometry.IsSchemeTheoreticallyDominant | true |
Int.isSquare_natCast_iff._simp_1 | Mathlib.Algebra.Ring.Int.Parity | ∀ {n : ℕ}, IsSquare ↑n = IsSquare n | false |
AddCommGrpCat.forget_commGrp_preserves_mono | Mathlib.Algebra.Category.Grp.EpiMono | (CategoryTheory.forget AddCommGrpCat).PreservesMonomorphisms | true |
Array.getElem_modify._proof_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {f : α → α} {xs : Array α} {j i : ℕ}, i < (xs.modify j f).size → i < xs.size | false |
Function.Surjective.distribMulActionLeft._proof_3 | Mathlib.Algebra.GroupWithZero.Action.End | ∀ {R : Type u_3} {S : Type u_2} {M : Type u_1} [inst : Monoid R] [inst_1 : AddMonoid M] [inst_2 : DistribMulAction R M]
[inst_3 : Monoid S] [inst_4 : SMul S M] (f : R →* S) (hf : Function.Surjective ⇑f)
(hsmul : ∀ (c : R) (x : M), f c • x = c • x) (a : S) (x y : M), a • (x + y) = a • x + a • y | false |
Lean.Elab.Tactic.Omega.MetaProblem.processedFacts._default | Lean.Elab.Tactic.Omega.Frontend | Std.HashSet Lean.Expr | false |
Part.map_Dom | Mathlib.Data.Part | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (o : Part α), (Part.map f o).Dom = o.Dom | true |
_private.Std.Time.Date.PlainDate.0.Std.Time.PlainDate.weekOfMonth._proof_1 | Std.Time.Date.PlainDate | 7 > 0 | false |
Mathlib.Meta.FunProp.FunctionTheorems.recOn | Mathlib.Tactic.FunProp.Theorems | {motive : Mathlib.Meta.FunProp.FunctionTheorems → Sort u} →
(t : Mathlib.Meta.FunProp.FunctionTheorems) →
((theorems :
Std.TreeMap Lean.Name (Std.TreeMap Lean.Name (Array Mathlib.Meta.FunProp.FunctionTheorem) Lean.Name.quickCmp)
Lean.Name.quickCmp) →
motive { theorems := theorems }) →
motive t | false |
UniformFun.instPseudoEMetricSpace._proof_2 | Mathlib.Topology.MetricSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoEMetricSpace β] (x y : UniformFun α β), edist x y = edist y x | false |
MeasurableDiv.measurable_const_div | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {G₀ : Type u_2} {inst : MeasurableSpace G₀} {inst_1 : Div G₀} [self : MeasurableDiv G₀] (c : G₀),
Measurable fun x => c / x | true |
Aesop.ForwardState.eraseHyp | Aesop.Forward.State | Lean.FVarId → Aesop.ForwardState → Aesop.ForwardState | true |
_private.Mathlib.NumberTheory.Chebyshev.0.Chebyshev.integral_1_div_log_sq_le._simp_1_5 | Mathlib.NumberTheory.Chebyshev | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | false |
CategoryTheory.MorphismProperty.IsWeakFactorizationSystem.hasFactorization | Mathlib.CategoryTheory.MorphismProperty.WeakFactorizationSystem | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {W₁ W₂ : CategoryTheory.MorphismProperty C}
[self : W₁.IsWeakFactorizationSystem W₂], W₁.HasFactorization W₂ | true |
NumberField.Units.fundSystem.eq_1 | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] (i : Fin (NumberField.Units.rank K)),
NumberField.Units.fundSystem K i = Quotient.out (Additive.toMul ((NumberField.Units.basisModTorsion K) i)) | true |
CategoryTheory.ObjectProperty.instIsMultiplicativeIsColocal | Mathlib.CategoryTheory.Localization.Bousfield | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.ObjectProperty C),
P.isColocal.IsMultiplicative | true |
CategoryTheory.MorphismProperty.RightFraction₂ | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] → CategoryTheory.MorphismProperty C → C → C → Type (max u_1 v_1) | true |
CategoryTheory.ShortComplex.LeftHomologyData.ofHasKernel.eq_1 | 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) [inst_2 : CategoryTheory.Limits.HasKernel S.g] (hf : S.f = 0),
CategoryTheory.ShortComplex.LeftHomologyData.ofHasKernel S hf =
CategoryTheory.ShortComplex.LeftHomologyData.ofIsLimitKernelFork S hf
(CategoryTheory.Limits.Fork.ofι (CategoryTheory.Limits.kernel.ι S.g) ⋯) (CategoryTheory.Limits.kernelIsKernel S.g) | true |
List.replace_append_right | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] {a b : α} [LawfulBEq α] {l₁ l₂ : List α},
a ∉ l₁ → (l₁ ++ l₂).replace a b = l₁ ++ l₂.replace a b | true |
CategoryTheory.Limits.coneLeftOpOfCoconeEquiv_functor_map_hom | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J Cᵒᵖ} {x x_1 : (CategoryTheory.Limits.Cocone F)ᵒᵖ} (f : x ⟶ x_1),
(CategoryTheory.Limits.coneLeftOpOfCoconeEquiv.functor.map f).hom = f.unop.hom.unop | true |
BoolRing.instCategory._proof_1 | Mathlib.Algebra.Category.BoolRing | ∀ {X Y : BoolRing} (f : X.Hom Y), { hom' := f.hom'.comp { hom' := RingHom.id ↑X }.hom' } = f | false |
CategoryTheory.Subobject.mk | Mathlib.CategoryTheory.Subobject.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X A : C} → (f : A ⟶ X) → [CategoryTheory.Mono f] → CategoryTheory.Subobject X | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_modify_self._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
IsAddFreimanIso.bijOn | Mathlib.Combinatorics.Additive.FreimanHom | ∀ {α : Type u_2} {β : Type u_3} [inst : AddCommMonoid α] [inst_1 : AddCommMonoid β] {n : ℕ} {A : Set α} {B : Set β}
{f : α → β}, IsAddFreimanIso n A B f → Set.BijOn f A B | true |
_private.Mathlib.Analysis.Normed.Module.Alternating.Uncurry.Fin.0.ContinuousAlternatingMap.alternatizeUncurryFinCLM.aux._proof_5 | Mathlib.Analysis.Normed.Module.Alternating.Uncurry.Fin | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F], SMulCommClass 𝕜 𝕜 F | false |
Mathlib.Meta.FunProp.Origin.casesOn | Mathlib.Tactic.FunProp.Types | {motive : Mathlib.Meta.FunProp.Origin → Sort u} →
(t : Mathlib.Meta.FunProp.Origin) →
((name : Lean.Name) → motive (Mathlib.Meta.FunProp.Origin.decl name)) →
((fvarId : Lean.FVarId) → motive (Mathlib.Meta.FunProp.Origin.fvar fvarId)) → motive t | false |
ContinuousMultilinearMap.piLinearEquiv._proof_5 | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {ι : Type u_2} {M₁ : ι → Type u_3} {R' : Type u_6} {A : Type u_1} [inst : Semiring R'] [inst_1 : Semiring A]
[inst_2 : (i : ι) → AddCommMonoid (M₁ i)] [inst_3 : (i : ι) → TopologicalSpace (M₁ i)]
[inst_4 : (i : ι) → Module A (M₁ i)] {ι' : Type u_5} {M' : ι' → Type u_4} [inst_5 : (i : ι') → AddCommMonoid (M' i)]
[inst_6 : (i : ι') → TopologicalSpace (M' i)] [inst_7 : ∀ (i : ι'), ContinuousAdd (M' i)]
[inst_8 : (i : ι') → Module R' (M' i)] [inst_9 : (i : ι') → Module A (M' i)]
[inst_10 : ∀ (i : ι'), SMulCommClass A R' (M' i)] [inst_11 : ∀ (i : ι'), ContinuousConstSMul R' (M' i)] (x : R')
(x_1 : (i : ι') → ContinuousMultilinearMap A M₁ (M' i)),
ContinuousMultilinearMap.piEquiv.toFun (x • x_1) = ContinuousMultilinearMap.piEquiv.toFun (x • x_1) | false |
Lean.Parser.Tactic.rwRuleSeq | Init.Tactics | Lean.ParserDescr | true |
Valued.integer.coe_span_singleton_eq_closedBall | Mathlib.Topology.Algebra.Valued.LocallyCompact | ∀ {K : Type u_1} [inst : NontriviallyNormedField K] [inst_1 : IsUltrametricDist K] (x : ↥(Valued.integer K)),
↑(Ideal.span {x}) = Metric.closedBall 0 ‖x‖ | true |
TopCat.Presheaf.IsLocallySurjective | Mathlib.Topology.Sheaves.LocallySurjective | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{FC : C → C → Type u_1} →
{CC : C → Type v} →
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] →
[CategoryTheory.ConcreteCategory C FC] → {X : TopCat} → {ℱ 𝒢 : TopCat.Presheaf C X} → (ℱ ⟶ 𝒢) → Prop | true |
IsCoprime.pow | Mathlib.RingTheory.Coprime.Lemmas | ∀ {R : Type u} [inst : CommSemiring R] {x y : R} {m n : ℕ}, IsCoprime x y → IsCoprime (x ^ m) (y ^ n) | true |
RingHom.id_comp | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_2} {β : Type u_3} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β} (f : α →+* β),
(RingHom.id β).comp f = f | true |
MonoidAlgebra.curryRingEquiv._proof_2 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_3} {N : Type u_2} [inst : Semiring R] [inst_1 : Monoid M] [inst_2 : Monoid N]
(x y : MonoidAlgebra R (M × N)),
Finsupp.curryAddEquiv.toFun (x + y) = Finsupp.curryAddEquiv.toFun x + Finsupp.curryAddEquiv.toFun y | false |
Subalgebra.equivOfEq_symm | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (S T : Subalgebra R A)
(h : S = T), (S.equivOfEq T h).symm = T.equivOfEq S ⋯ | true |
ENNReal.div_add_div_same | Mathlib.Data.ENNReal.Inv | ∀ {a b c : ENNReal}, a / c + b / c = (a + b) / c | true |
LLVM.constInt1 | Lean.Compiler.IR.LLVMBindings | (ctx : LLVM.Context) → UInt64 → optParam Bool false → BaseIO (LLVM.Value ctx) | true |
norm_innerSL_le | Mathlib.Analysis.InnerProductSpace.LinearMap | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E],
‖innerSL 𝕜‖ ≤ 1 | true |
AddSubmonoid.mem_closure_finset | Mathlib.Algebra.Group.Submonoid.BigOperators | ∀ {M : Type u_1} [inst : AddCommMonoid M] {x : M} {s : Finset M},
x ∈ AddSubmonoid.closure ↑s ↔ ∃ f, Function.support f ⊆ ↑s ∧ ∑ a ∈ s, f a • a = x | true |
UniformFun.ofFun_smul | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : SMul M β] (c : M) (f : α → β),
UniformFun.ofFun (c • f) = c • UniformFun.ofFun f | true |
CommRingCat.KaehlerDifferential.ext_iff | Mathlib.Algebra.Category.ModuleCat.Differentials.Basic | ∀ {A B : CommRingCat} {f : A ⟶ B} {M : ModuleCat ↑B} {α β : CommRingCat.KaehlerDifferential f ⟶ M},
α = β ↔
∀ (b : ↑B),
(CategoryTheory.ConcreteCategory.hom α) (CommRingCat.KaehlerDifferential.d b) =
(CategoryTheory.ConcreteCategory.hom β) (CommRingCat.KaehlerDifferential.d b) | true |
Lean.Export.Entry | Mathlib.Util.Export | Type | true |
ArithmeticFunction.pow_apply | Mathlib.NumberTheory.ArithmeticFunction.Misc | ∀ {k n : ℕ}, (ArithmeticFunction.pow k) n = if k = 0 ∧ n = 0 then 0 else n ^ k | true |
RingHom.Flat.tensorProductMap | Mathlib.RingTheory.RingHom.Flat | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {A : Type u_4}
{B : Type u_5} {C : Type u_6} {D : Type u_7} [inst_3 : CommRing A] [inst_4 : Algebra R A] [inst_5 : Algebra S A]
[inst_6 : IsScalarTower R S A] [inst_7 : CommRing B] [inst_8 : Algebra R B] [inst_9 : CommRing C]
[inst_10 : Algebra R C] [inst_11 : Algebra S C] [inst_12 : IsScalarTower R S C] [inst_13 : CommRing D]
[inst_14 : Algebra R D] {f : A →ₐ[S] C} {g : B →ₐ[R] D}, f.Flat → g.Flat → (Algebra.TensorProduct.map f g).Flat | true |
Polynomial.Splits.coeff_zero_eq_leadingCoeff_mul_prod_roots | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : CommRing R] {f : Polynomial R} [inst_1 : IsDomain R],
f.Splits → f.coeff 0 = (-1) ^ f.natDegree * f.leadingCoeff * f.roots.prod | true |
Lean.Elab.Tactic.MkSimpContextResult._sizeOf_1 | Lean.Elab.Tactic.Simp | Lean.Elab.Tactic.MkSimpContextResult → ℕ | false |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_15 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} (head : α) (tail : List α) (i j k : ℕ),
i < j → j < k → k < tail.length + 1 → ¬i = 0 → i - 1 < tail.length | false |
_private.Lean.Meta.Sym.Intro.0.Lean.Meta.Sym.introCore.visit._unsafe_rec | Lean.Meta.Sym.Intro | ℕ →
(Lean.LocalContext →
Lean.LocalInstances → Array Lean.Expr → Lean.Expr → Lean.Meta.Sym.SymM (Array Lean.Expr × Lean.MVarId)) →
(Lean.Name → ℕ → Lean.MetaM Lean.Name) →
(Lean.LocalInstances → Lean.Expr → Lean.Expr → Lean.LocalInstances) →
ℕ →
Lean.LocalContext →
Lean.LocalInstances → Array Lean.Expr → Lean.Expr → Lean.Meta.Sym.SymM (Array Lean.Expr × Lean.MVarId) | false |
CategoryTheory.Functor.FullyFaithful.homNatIso_hom_app_down | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) (X : C) (X_1 : Cᵒᵖ)
(a : (F.op.comp (CategoryTheory.uliftYoneda.{v₁, v₂, u₂}.obj (F.obj X))).obj X_1),
((hF.homNatIso X).hom.app X_1 a).down = hF.preimage (Equiv.ulift a) | true |
Std.Do.WPMonad.rec | Std.Do.WP.Monad | {m : Type u → Type v} →
{ps : Std.Do.PostShape} →
[inst : Monad m] →
{motive : Std.Do.WPMonad m ps → Sort u_1} →
([toLawfulMonad : LawfulMonad m] →
[toWP : Std.Do.WP m ps] →
(wp_pure : ∀ {α : Type u} (a : α), Std.Do.wp (pure a) = pure a) →
(wp_bind :
∀ {α β : Type u} (x : m α) (f : α → m β),
(Std.Do.wp do
let a ← x
f a) =
do
let a ← Std.Do.wp x
Std.Do.wp (f a)) →
motive { toLawfulMonad := toLawfulMonad, toWP := toWP, wp_pure := wp_pure, wp_bind := wp_bind }) →
(t : Std.Do.WPMonad m ps) → motive t | false |
Sum.elim_inr | Init.Data.Sum.Basic | ∀ {α : Type u_1} {γ : Sort u_2} {β : Type u_3} (f : α → γ) (g : β → γ) (x : β), Sum.elim f g (Sum.inr x) = g x | true |
instHAppendOfAppend | Init.Prelude | {α : Type u_1} → [Append α] → HAppend α α α | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getD_diff._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) | false |
_private.Mathlib.RingTheory.RootsOfUnity.Basic.0.map_rootsOfUnity._simp_1_1 | Mathlib.RingTheory.RootsOfUnity.Basic | ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : Monoid G] [inst_2 : Monoid H]
[MonoidHomClass F G H] (f : F) (a : G) (n : ℕ), f a ^ n = f (a ^ n) | false |
List.dropInfix?.go | Batteries.Data.List.Basic | {α : Type u_1} → [BEq α] → List α → List α → List α → Option (List α × List α) | true |
Std.Roi.toArray_iter | Std.Data.Iterators.Lemmas.Producers.Range | ∀ {α : Type u_1} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.Rxi.IsAlwaysFinite α]
[inst_2 : Std.PRange.LawfulUpwardEnumerable α] {r : Std.Roi α}, r.iter.toArray = r.toArray | true |
NeZero.of_gt' | Mathlib.Algebra.Order.Monoid.Canonical.Defs | ∀ {M : Type u_1} [inst : AddZeroClass M] [inst_1 : Preorder M] [CanonicallyOrderedAdd M] [inst_3 : One M] {y : M}
[Fact (1 < y)], NeZero y | true |
CategoryTheory.Limits.IndizationClosedUnderFilteredColimitsAux.compYonedaColimitIsoColimitCompYoneda._proof_6 | Mathlib.CategoryTheory.Limits.Indization.FilteredColimits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {I : Type u_1} [inst_1 : CategoryTheory.SmallCategory I]
(F : CategoryTheory.Functor I (CategoryTheory.Functor Cᵒᵖ (Type u_1))) {J : Type u_1}
[inst_2 : CategoryTheory.SmallCategory J]
(G :
CategoryTheory.Functor J (CategoryTheory.CostructuredArrow CategoryTheory.yoneda (CategoryTheory.Limits.colimit F)))
{K : Type u_1} [inst_3 : CategoryTheory.SmallCategory K]
(H : CategoryTheory.Functor K (CategoryTheory.Over (CategoryTheory.Limits.colimit F))),
CategoryTheory.Limits.HasColimit
(H.comp
(CategoryTheory.yoneda.comp
((CategoryTheory.Functor.whiskeringLeft Jᵒᵖ (CategoryTheory.Over (CategoryTheory.Limits.colimit F))ᵒᵖ
(Type (max u_2 u_1))).obj
(G.op.comp
(CategoryTheory.CostructuredArrow.toOver CategoryTheory.yoneda (CategoryTheory.Limits.colimit F)).op)))) | false |
ZeroAtInftyContinuousMap.instMulActionWithZero._proof_1 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Zero β]
{R : Type u_3} [inst_3 : MonoidWithZero R] [inst_4 : MulActionWithZero R β] [inst_5 : ContinuousConstSMul R β] (r : R)
(f : ZeroAtInftyContinuousMap α β), ⇑(r • f) = r • ⇑f | false |
IsCancelVAdd.mk | Mathlib.Algebra.Group.Action.Defs | ∀ {G : Type u_9} {P : Type u_10} [inst : VAdd G P] [toIsLeftCancelVAdd : IsLeftCancelVAdd G P],
(∀ (a b : G) (c : P), a +ᵥ c = b +ᵥ c → a = b) → IsCancelVAdd G P | true |
instModuleZModOfNatNatAdditiveUnitsInt._proof_1 | Mathlib.Data.ZMod.IntUnitsPower | ∀ (z₁ z₂ : ZMod 2) (au : Additive ℤˣ), Additive.toMul ((z₁ * z₂) • au) = Additive.toMul (z₁ • z₂ • au) | false |
GradedLieAlgebra.mk | Mathlib.Algebra.Lie.Graded | {ι : Type u_1} →
{R : Type u_3} →
{L : Type u_4} →
[inst : DecidableEq ι] →
[inst_1 : AddCommMonoid ι] →
[inst_2 : CommRing R] →
[inst_3 : LieRing L] →
[inst_4 : LieAlgebra R L] →
{ℒ : ι → Submodule R L} →
[toGradedBracket : SetLike.GradedBracket ℒ] →
[toDecomposition : DirectSum.Decomposition ℒ] → GradedLieAlgebra ℒ | true |
_private.Mathlib.RingTheory.Algebraic.Integral.0.Algebra.IsIntegral.isAlgebraic_iff_top._simp_1_1 | Mathlib.RingTheory.Algebraic.Integral | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A],
Algebra.IsAlgebraic R A = ∀ (x : A), IsAlgebraic R x | false |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Elab.Tactic.Induction | Lean.Elab.Tactic.Tactic | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxOf_eq_idxOfNth_add._proof_1_43 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} [inst : BEq α] (head : α) (tail : List α) {n s : ℕ}
{h : n < (List.idxsOf x (head :: tail) s).length}, ¬(head == x) = true → n < (List.idxsOf x tail (s + 1)).length | false |
Unitization.instSub | Mathlib.Algebra.Algebra.Unitization | {R : Type u_3} → {A : Type u_4} → [Sub R] → [Sub A] → Sub (Unitization R A) | true |
Lean.Meta.FunInfo.mk._flat_ctor | Lean.Meta.Basic | Array Lean.Meta.ParamInfo → Array ℕ → Lean.Meta.FunInfo | false |
List.Forall₂ | Batteries.Data.List.Basic | {α : Type u_1} → {β : Type u_2} → (α → β → Prop) → List α → List β → Prop | true |
Dynamics.coverEntropyEntourage_union | Mathlib.Dynamics.TopologicalEntropy.Subset | ∀ {X : Type u_1} {T : X → X} {F G : Set X} {U : SetRel X X},
Dynamics.coverEntropyEntourage T (F ∪ G) U =
max (Dynamics.coverEntropyEntourage T F U) (Dynamics.coverEntropyEntourage T G U) | true |
NNReal.coe_inj | Mathlib.Data.NNReal.Defs | ∀ {r₁ r₂ : NNReal}, ↑r₁ = ↑r₂ ↔ r₁ = r₂ | true |
CategoryTheory.Functor.LaxLeftLinear.μₗ_naturality_left._autoParam | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | Lean.Syntax | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.