name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Polynomial.cardPowDegree_isEuclidean | Mathlib.Algebra.Polynomial.Degree.CardPowDegree | ∀ {Fq : Type u_1} [inst : Field Fq] [inst_1 : Fintype Fq], Polynomial.cardPowDegree.IsEuclidean | true |
_private.Init.Data.Nat.Lemmas.0.Nat.exists_eq_add_one.match_1_1 | Init.Data.Nat.Lemmas | ∀ {a : ℕ} (motive : (∃ n, a = n + 1) → Prop) (x : ∃ n, a = n + 1), (∀ (n : ℕ) (h : a = n + 1), motive ⋯) → motive x | false |
NNReal.sqrt_eq_one._simp_1 | Mathlib.Data.Real.Sqrt | ∀ {x : NNReal}, (NNReal.sqrt x = 1) = (x = 1) | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0._regBuiltin.UInt8.reduceNe.declare_58._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.781669616._hygCtx.3.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.781669616._hygCtx._hyg.257 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | false |
List.IsChain.count_not_le_count_add_one | Mathlib.Data.Bool.Count | ∀ {l : List Bool}, List.IsChain (fun x1 x2 => x1 ≠ x2) l → ∀ (b : Bool), List.count (!b) l ≤ List.count b l + 1 | true |
CategoryTheory.MonoidalClosed.whiskerLeft_curry'_ihom_ev_app_assoc | Mathlib.CategoryTheory.Monoidal.Closed.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : C}
[inst_2 : CategoryTheory.Closed X] (f : X ⟶ Y) {Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.MonoidalClosed.curry' f))
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.ihom.ev X).app Y) h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).hom
(CategoryTheory.CategoryStruct.comp f h) | true |
CategoryTheory.Pseudofunctor.Grothendieck.category._proof_3 | Mathlib.CategoryTheory.Bicategory.Grothendieck | ∀ {𝒮 : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} 𝒮]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮) CategoryTheory.Cat} {a b : F.Grothendieck}
(f : a ⟶ b), CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id a) f = f | false |
Finset.weightedVSubVSubWeights_apply_left | Mathlib.LinearAlgebra.AffineSpace.Combination | ∀ (k : Type u_1) [inst : Ring k] {ι : Type u_4} [inst_1 : DecidableEq ι] {i j : ι},
i ≠ j → Finset.weightedVSubVSubWeights k i j i = 1 | true |
CategoryTheory.ComposableArrows.isoMkSucc._proof_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C (n + 1)}
(α : F.obj' 0 ⋯ ≅ G.obj' 0 ⋯) (β : F.δ₀ ≅ G.δ₀),
CategoryTheory.CategoryStruct.comp (F.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 ⋯)
(CategoryTheory.ComposableArrows.app' β.hom 0 ⋯) =
CategoryTheory.CategoryStruct.comp α.hom (G.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 ⋯) →
CategoryTheory.CategoryStruct.comp (G.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 ⋯)
(CategoryTheory.ComposableArrows.app' β.inv 0 ⋯) =
CategoryTheory.CategoryStruct.comp α.inv (F.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 ⋯) | false |
_private.Lean.Meta.Match.SolveOverlap.0.Lean.Meta.Match.InjectionAnyResult.failed.sizeOf_spec | Lean.Meta.Match.SolveOverlap | sizeOf Lean.Meta.Match.InjectionAnyResult.failed✝ = 1 | true |
FreeAbelianGroup.instCommApplicative | Mathlib.GroupTheory.FreeAbelianGroup | CommApplicative FreeAbelianGroup | true |
dslope_eventuallyEq_slope_of_ne | Mathlib.Analysis.Calculus.DSlope | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {a b : 𝕜} (f : 𝕜 → E), b ≠ a → dslope f a =ᶠ[nhds b] slope f a | true |
SimpleGraph.IsAcyclic.isPath_iff_isTrail | Mathlib.Combinatorics.SimpleGraph.Acyclic | ∀ {V : Type u_1} {G : SimpleGraph V}, G.IsAcyclic → ∀ {v w : V} (p : G.Walk v w), p.IsPath ↔ p.IsTrail | true |
FirstOrder.Language.Substructure.closure_empty | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M],
(FirstOrder.Language.Substructure.closure L).toFun ∅ = ⊥ | true |
Lean.Parser.Term.doIf._regBuiltin.Lean.Parser.Term.doIf.declRange_3 | Lean.Parser.Do | IO Unit | false |
CategoryTheory.Limits.hasEqualizer_of_hasSplitEqualizer | Mathlib.CategoryTheory.Limits.Shapes.SplitEqualizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y) [CategoryTheory.HasSplitEqualizer f g],
CategoryTheory.Limits.HasEqualizer f g | true |
LocallyConstant.comap._proof_1 | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_3} {Z : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : C(X, Y))
(g : LocallyConstant Y Z), IsLocallyConstant (g.toFun ∘ ⇑f) | false |
Metric.unitBall.coe_mul | Mathlib.Analysis.Normed.Field.UnitBall | ∀ {𝕜 : Type u_1} [inst : NonUnitalSeminormedRing 𝕜] (x y : ↑(Metric.ball 0 1)), ↑(x * y) = ↑x * ↑y | true |
Lean.instToMessageDataProd | Lean.Message | {α β : Type} → [Lean.ToMessageData α] → [Lean.ToMessageData β] → Lean.ToMessageData (α × β) | true |
DirectLimit.instModule._proof_3 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {R : Type u_3} {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_4} {T : ⦃i j : ι⦄ → i ≤ j → Type u_2}
[inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)] [inst_2 : Semiring R]
[inst_3 : (i : ι) → AddCommMonoid (G i)] [inst_4 : (i : ι) → Module R (G i)]
[∀ (i j : ι) (h : i ≤ j), LinearMapClass (T h) R (G i) (G j)] (i j : ι) (h : i ≤ j),
DistribMulActionHomClass (T h) R (G i) (G j) | false |
_private.Lean.Environment.0.Lean.ImportState.markAllExported.match_1 | Lean.Environment | (motive : Lean.Name × Lean.ImportedModule✝ → Sort u_1) →
(x : Lean.Name × Lean.ImportedModule✝¹) → ((k : Lean.Name) → (v : Lean.ImportedModule✝²) → motive (k, v)) → motive x | false |
PNat.sub_le | Mathlib.Data.PNat.Basic | ∀ (a b : ℕ+), a - b ≤ a | true |
Mathlib.Tactic.BicategoryLike.MonadMor₂Iso.recOn | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {m : Type → Type} →
{motive : Mathlib.Tactic.BicategoryLike.MonadMor₂Iso m → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.MonadMor₂Iso m) →
((associatorM :
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ → m Mathlib.Tactic.BicategoryLike.StructuralAtom) →
(leftUnitorM rightUnitorM id₂M :
Mathlib.Tactic.BicategoryLike.Mor₁ → m Mathlib.Tactic.BicategoryLike.StructuralAtom) →
(coherenceHomM :
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ → Lean.Expr → m Mathlib.Tactic.BicategoryLike.CoherenceHom) →
(comp₂M :
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso → m Mathlib.Tactic.BicategoryLike.Mor₂Iso) →
(whiskerLeftM :
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₂Iso → m Mathlib.Tactic.BicategoryLike.Mor₂Iso) →
(whiskerRightM :
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₁ → m Mathlib.Tactic.BicategoryLike.Mor₂Iso) →
(horizontalCompM :
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso → m Mathlib.Tactic.BicategoryLike.Mor₂Iso) →
(symmM : Mathlib.Tactic.BicategoryLike.Mor₂Iso → m Mathlib.Tactic.BicategoryLike.Mor₂Iso) →
(coherenceCompM :
Mathlib.Tactic.BicategoryLike.CoherenceHom →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso → m Mathlib.Tactic.BicategoryLike.Mor₂Iso) →
motive
{ associatorM := associatorM, leftUnitorM := leftUnitorM, rightUnitorM := rightUnitorM,
id₂M := id₂M, coherenceHomM := coherenceHomM, comp₂M := comp₂M,
whiskerLeftM := whiskerLeftM, whiskerRightM := whiskerRightM,
horizontalCompM := horizontalCompM, symmM := symmM, coherenceCompM := coherenceCompM }) →
motive t | false |
CategoryTheory.MorphismProperty.IsStableUnderTransfiniteCompositionOfShape.rec | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W : CategoryTheory.MorphismProperty C} →
{J : Type w} →
[inst_1 : LinearOrder J] →
[inst_2 : SuccOrder J] →
[inst_3 : OrderBot J] →
[inst_4 : WellFoundedLT J] →
{motive : W.IsStableUnderTransfiniteCompositionOfShape J → Sort u_1} →
((le : W.transfiniteCompositionsOfShape J ≤ W) → motive ⋯) →
(t : W.IsStableUnderTransfiniteCompositionOfShape J) → motive t | false |
ContinuousAt.fun_add | Mathlib.Topology.Algebra.Monoid.Defs | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : Add M] [ContinuousAdd M] {X : Type u_2}
[inst_3 : TopologicalSpace X] {f g : X → M} {x : X},
ContinuousAt f x → ContinuousAt g x → ContinuousAt (fun i => f i + g i) x | true |
Mathlib.Tactic.Linarith.GlobalPreprocessor.rec | Mathlib.Tactic.Linarith.Datatypes | {motive : Mathlib.Tactic.Linarith.GlobalPreprocessor → Sort u} →
((toPreprocessorBase : Mathlib.Tactic.Linarith.PreprocessorBase) →
(transform : List Lean.Expr → Lean.MetaM (List Lean.Expr)) →
motive { toPreprocessorBase := toPreprocessorBase, transform := transform }) →
(t : Mathlib.Tactic.Linarith.GlobalPreprocessor) → motive t | false |
SignType.neg | Mathlib.Data.Sign.Defs | SignType | true |
BoxIntegral.integral_zero | Mathlib.Analysis.BoxIntegral.Basic | ∀ {ι : Type u} {E : Type v} {F : Type w} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {I : BoxIntegral.Box ι} [inst_4 : Fintype ι]
{l : BoxIntegral.IntegrationParams} {vol : BoxIntegral.BoxAdditiveMap ι (E →L[ℝ] F) ⊤},
BoxIntegral.integral I l (fun x => 0) vol = 0 | true |
SlashInvariantForm.instAddCommGroup._proof_5 | Mathlib.NumberTheory.ModularForms.SlashInvariantForms | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {k : ℤ} (f : SlashInvariantForm Γ k) (n : ℕ), ⇑(n • f) = n • ⇑f | false |
Polynomial.Chebyshev.integral_eval_T_real_mul_self_measureT_zero | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Orthogonality | ∫ (x : ℝ),
Polynomial.eval x (Polynomial.Chebyshev.T ℝ 0) *
Polynomial.eval x (Polynomial.Chebyshev.T ℝ 0) ∂Polynomial.Chebyshev.measureT =
Real.pi | true |
CategoryTheory.CechNerveTerminalFrom.wideCospan.limitIsoPi_hom_comp_pi_assoc | Mathlib.AlgebraicTopology.CechNerve | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasTerminal C] (ι : Type w)
[inst_2 : CategoryTheory.Limits.HasFiniteProducts C] [inst_3 : Finite ι] (X : C) (j : ι) {Z : C} (h : X ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CechNerveTerminalFrom.wideCospan.limitIsoPi ι X).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.π (fun x => X) j) h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.WidePullback.π (fun x => CategoryTheory.Limits.terminal.from X) j) h | true |
CategoryTheory.Pseudofunctor.DescentData.toDescentDataCompPullFunctorIso._proof_9 | Mathlib.CategoryTheory.Sites.Descent.DescentData | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_5, u_3} C]
(F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat) {ι : Type u_6} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} {S' : C} {p : S' ⟶ S} {ι' : Type u_1} {X' : ι' → C} {f' : (j : ι') → X' j ⟶ S'}
{α : ι' → ι} {p' : (j : ι') → X' j ⟶ X (α j)}
(w : ∀ (j : ι'), CategoryTheory.CategoryStruct.comp (p' j) (f (α j)) = CategoryTheory.CategoryStruct.comp (f' j) p)
{X_1 Y : ↑(F.obj { as := Opposite.op S })} (f_1 : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((F.toDescentData f).comp (CategoryTheory.Pseudofunctor.DescentData.pullFunctor F w)).map f_1)
((fun M =>
CategoryTheory.Pseudofunctor.DescentData.isoMk
(fun i => (CategoryTheory.Cat.Hom.toNatIso (F.isoMapOfCommSq ⋯)).symm.app M) ⋯)
Y).hom =
CategoryTheory.CategoryStruct.comp
((fun M =>
CategoryTheory.Pseudofunctor.DescentData.isoMk
(fun i => (CategoryTheory.Cat.Hom.toNatIso (F.isoMapOfCommSq ⋯)).symm.app M) ⋯)
X_1).hom
(((F.map p.op.toLoc).toFunctor.comp (F.toDescentData f')).map f_1) | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj.0.CategoryTheory.Functor.LeibnizAdjunction.adj._simp_2 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)}
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} (adj₂ : F ⊣₂ G) {X₁ : C₁} {X₂ : C₂} {X₃ Y₃ : C₃}
(f₃ : X₃ ⟶ Y₃) (g : (F.obj X₁).obj X₂ ⟶ X₃),
CategoryTheory.CategoryStruct.comp (adj₂.homEquiv g) ((G.obj (Opposite.op X₁)).map f₃) =
adj₂.homEquiv (CategoryTheory.CategoryStruct.comp g f₃) | false |
Besicovitch.SatelliteConfig.inter' | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} [inst : MetricSpace α] {N : ℕ} {τ : ℝ} (a : Besicovitch.SatelliteConfig α N τ) (i : Fin N.succ),
dist (a.c i) (a.c (Fin.last N)) ≤ a.r i + a.r (Fin.last N) | true |
ULift.semigroup | Mathlib.Algebra.Group.ULift | {α : Type u} → [Semigroup α] → Semigroup (ULift.{u_1, u} α) | true |
Aesop.RulePatternIndex.instInhabitedEntry.default | Aesop.Index.RulePattern | Aesop.RulePatternIndex.Entry | true |
AlgEquiv.commutes' | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (self : A ≃ₐ[R] B) (r : R),
self.toFun ((algebraMap R A) r) = (algebraMap R B) r | true |
CategoryTheory.Subobject.imageFactorisation_F_I | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} [inst_1 : CategoryTheory.Limits.HasImages C]
(f : X ⟶ Y) (x : CategoryTheory.Subobject X),
(CategoryTheory.Subobject.imageFactorisation f x).F.I =
CategoryTheory.Subobject.underlying.obj ((CategoryTheory.Subobject.exists f).obj x) | true |
_private.Mathlib.Analysis.Complex.Basic.0.Complex.mem_slitPlane_or_neg_mem_slitPlane._simp_1_1 | Mathlib.Analysis.Complex.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddLeftStrictMono α] {a : α}, (0 < -a) = (a < 0) | false |
FreeLieAlgebra.liftAux_map_add | Mathlib.Algebra.Lie.Free | ∀ (R : Type u) {X : Type v} [inst : CommRing R] {L : Type w} [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (f : X → L)
(a b : FreeNonUnitalNonAssocAlgebra R X),
(FreeLieAlgebra.liftAux R f) (a + b) = (FreeLieAlgebra.liftAux R f) a + (FreeLieAlgebra.liftAux R f) b | true |
Finset.prod_range_div_prod_range | Mathlib.Algebra.BigOperators.Intervals | ∀ {G : Type u_4} [inst : CommGroup G] {f : ℕ → G} {n m : ℕ},
n ≤ m → (∏ k ∈ Finset.range m, f k) / ∏ k ∈ Finset.range n, f k = ∏ k ∈ Finset.range m with n ≤ k, f k | true |
Set.union_add_inter_subset | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : AddCommSemigroup α] {s t : Set α}, s ∪ t + s ∩ t ⊆ s + t | true |
Ordnode.Bounded.weak_right | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} [inst : Preorder α] {t : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α}, t.Bounded o₁ o₂ → t.Bounded o₁ ⊤ | true |
SetLike.gmodule | Mathlib.Algebra.Module.GradedModule | {ιA : Type u_1} →
{ιM : Type u_2} →
{A : Type u_4} →
{M : Type u_5} →
{σ : Type u_6} →
{σ' : Type u_7} →
[inst : AddMonoid ιA] →
[inst_1 : AddAction ιA ιM] →
[inst_2 : Semiring A] →
(𝓐 : ιA → σ') →
[inst_3 : SetLike σ' A] →
(𝓜 : ιM → σ) →
[inst_4 : AddCommMonoid M] →
[inst_5 : Module A M] →
[inst_6 : SetLike σ M] →
[inst_7 : AddSubmonoidClass σ' A] →
[inst_8 : AddSubmonoidClass σ M] →
[inst_9 : SetLike.GradedMonoid 𝓐] →
[SetLike.GradedSMul 𝓐 𝓜] → DirectSum.Gmodule (fun i => ↥(𝓐 i)) fun i => ↥(𝓜 i) | true |
Ideal.span_pow_eq_top | Mathlib.RingTheory.Ideal.Basic | ∀ {α : Type u_2} [inst : CommSemiring α] (s : Set α),
Ideal.span s = ⊤ → ∀ (n : ℕ), Ideal.span ((fun x => x ^ n) '' s) = ⊤ | true |
Matroid.rankPos_nonempty | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} [M.RankPos], M.Nonempty | true |
Vector.replace_toArray | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} [inst : BEq α] {xs : Vector α n} {a b : α}, xs.toArray.replace a b = (xs.replace a b).toArray | true |
ContinuousMultilinearMap.flipLinear._proof_3 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u_4} {ι : Type u_1} {E : ι → Type u_2} {G : Type u_5} {G' : Type u_3} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : SeminormedAddCommGroup G']
[inst_6 : NormedSpace 𝕜 G'] (f : ContinuousMultilinearMap 𝕜 E (G →L[𝕜] G')) (x y : G),
{ toFun := fun m => (f m) (x + y), map_update_add' := ⋯, map_update_smul' := ⋯ } =
{ toFun := fun m => (f m) x, map_update_add' := ⋯, map_update_smul' := ⋯ } +
{ toFun := fun m => (f m) y, map_update_add' := ⋯, map_update_smul' := ⋯ } | false |
Lean.Meta.DiscrTree.Key.other.elim | Lean.Meta.DiscrTree.Types | {motive : Lean.Meta.DiscrTree.Key → Sort u} →
(t : Lean.Meta.DiscrTree.Key) → t.ctorIdx = 1 → motive Lean.Meta.DiscrTree.Key.other → motive t | false |
ENat.map_natCast_strictMono | Mathlib.Data.ENat.Basic | ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α] [AddLeftMono α] [ZeroLEOneClass α] [CharZero α],
StrictMono (ENat.map Nat.cast) | true |
AddGroupExtension._sizeOf_1 | Mathlib.GroupTheory.GroupExtension.Defs | {N : Type u_1} →
{E : Type u_2} →
{G : Type u_3} →
{inst : AddGroup N} →
{inst_1 : AddGroup E} →
{inst_2 : AddGroup G} → [SizeOf N] → [SizeOf E] → [SizeOf G] → AddGroupExtension N E G → ℕ | false |
ModuleCon.instAddMonoidQuotient | Mathlib.Algebra.Module.Congruence.Defs | {S : Type u_2} →
(M : Type u_3) → [inst : SMul S M] → [inst_1 : AddMonoid M] → (c : ModuleCon S M) → AddMonoid (ModuleCon.Quotient M c) | true |
LieSubalgebra.normalizer._proof_1 | Mathlib.Algebra.Lie.Normalizer | ∀ {R : Type u_2} {L : Type u_1} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(H : LieSubalgebra R L) {y z : L},
y ∈ (↑H.toLieSubmodule.normalizer).carrier →
z ∈ (↑H.toLieSubmodule.normalizer).carrier → ∀ (x : ↥H), ⁅x, ⁅y, z⁆⁆ ∈ H.toLieSubmodule | false |
Batteries.RBNode.Path.Ordered.eq_3 | Batteries.Data.RBMap.Alter | ∀ {α : Type u_1} (cmp : α → α → Ordering) (c : Batteries.RBColor) (l : Batteries.RBNode α) (x_1 : α)
(parent : Batteries.RBNode.Path α),
Batteries.RBNode.Path.Ordered cmp (Batteries.RBNode.Path.right c l x_1 parent) =
(Batteries.RBNode.Path.Ordered cmp parent ∧
Batteries.RBNode.All (fun x => Batteries.RBNode.cmpLT cmp x x_1) l ∧
Batteries.RBNode.Path.RootOrdered cmp parent x_1 ∧
Batteries.RBNode.All (Batteries.RBNode.Path.RootOrdered cmp parent) l ∧ Batteries.RBNode.Ordered cmp l) | true |
Subring.smul_sup | Mathlib.Algebra.Ring.Subring.Pointwise | ∀ {M : Type u_1} {R : Type u_2} [inst : Monoid M] [inst_1 : Ring R] [inst_2 : MulSemiringAction M R] (a : M)
(S T : Subring R), a • (S ⊔ T) = a • S ⊔ a • T | true |
_private.Lean.Compiler.IR.Basic.0.Lean.IR.FnBody.alphaEqv._sparseCasesOn_9 | Lean.Compiler.IR.Basic | {motive_2 : Lean.IR.FnBody → Sort u} →
(t : Lean.IR.FnBody) →
((x : Lean.IR.VarId) → (cidx : ℕ) → (b : Lean.IR.FnBody) → motive_2 (Lean.IR.FnBody.setTag x cidx b)) →
(Nat.hasNotBit 8 t.ctorIdx → motive_2 t) → motive_2 t | false |
AddSubsemigroup.map_map | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : Add M] [inst_1 : Add N] [inst_2 : Add P] (S : AddSubsemigroup M)
(g : N →ₙ+ P) (f : M →ₙ+ N), AddSubsemigroup.map g (AddSubsemigroup.map f S) = AddSubsemigroup.map (g.comp f) S | true |
List.takeWhile₂TR.go._sunfold | Batteries.Data.List.Basic | {α : Type u_1} → {β : Type u_2} → (α → β → Bool) → List α → List β → List α → List β → List α × List β | false |
CompHausLike.toCompHausLike._proof_1 | Mathlib.Topology.Category.CompHausLike.Basic | ∀ {P P' : TopCat → Prop} (h : ∀ (X : CompHausLike P), P X.toTop → P' X.toTop) (X : CompHausLike P),
CategoryTheory.ConcreteCategory.ofHom (TopCat.Hom.hom (CategoryTheory.CategoryStruct.id X).hom) =
CategoryTheory.CategoryStruct.id (CompHausLike.of P' ↑X.toTop) | false |
Bicategory.Opposite.opFunctor | Mathlib.CategoryTheory.Bicategory.Opposites | {B : Type u} →
[inst : CategoryTheory.Bicategory B] → (a b : B) → CategoryTheory.Functor (a ⟶ b) (Opposite.op b ⟶ Opposite.op a) | true |
Lean.Lsp.DidOpenTextDocumentParams.mk | Lean.Data.Lsp.TextSync | Lean.Lsp.TextDocumentItem → Lean.Lsp.DidOpenTextDocumentParams | true |
_private.Mathlib.Data.List.Destutter.0.List.le_length_destutter'_cons._simp_1_3 | Mathlib.Data.List.Destutter | ∀ (n : ℕ), (n ≤ n.succ) = True | false |
ProbabilityTheory.Kernel.Indep.eq_1 | Mathlib.Probability.Independence.Kernel.Indep | ∀ {α : Type u_1} {Ω : Type u_2} {_mα : MeasurableSpace α} (m₁ m₂ : MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω}
(κ : ProbabilityTheory.Kernel α Ω) (μ : MeasureTheory.Measure α),
ProbabilityTheory.Kernel.Indep m₁ m₂ κ μ =
ProbabilityTheory.Kernel.IndepSets {s | MeasurableSet s} {s | MeasurableSet s} κ μ | true |
Filter.Germ.instSemifield._proof_1 | Mathlib.Order.Filter.FilterProduct | ∀ {α : Type u_1} {β : Type u_2} {φ : Ultrafilter α} [inst : Semifield β] (a b : (↑φ).Germ β), a / b = a * b⁻¹ | false |
_private.Mathlib.Data.Set.Prod.0.Set.univ_pi_singleton._simp_1_1 | Mathlib.Data.Set.Prod | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.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) | false |
Matrix.conjTranspose_intCast_smul | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_7} {α : Type v} [inst : Ring R] [inst_1 : AddCommGroup α]
[inst_2 : StarAddMonoid α] [inst_3 : Module R α] (c : ℤ) (M : Matrix m n α),
(↑c • M).conjTranspose = ↑c • M.conjTranspose | true |
Algebra.TensorProduct.tensorQuotientEquiv_apply_tmul | Mathlib.RingTheory.TensorProduct.Quotient | ∀ {R : Type u_1} (S : Type u_2) (T : Type u_3) (A : Type u_4) [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : CommRing A] [inst_6 : Algebra R A]
[inst_7 : Algebra S A] [inst_8 : IsScalarTower R S A] (I : Ideal T) (a : A) (t : T),
(Algebra.TensorProduct.tensorQuotientEquiv S T A I) (a ⊗ₜ[R] (Ideal.Quotient.mk I) t) =
(Ideal.Quotient.mk (Ideal.map Algebra.TensorProduct.includeRight I)) (a ⊗ₜ[R] t) | true |
Lean.Elab.Term.MutualClosure.ClosureState.mk.noConfusion | Lean.Elab.MutualDef | {P : Sort u} →
{newLocalDecls localDecls newLetDecls : Array Lean.LocalDecl} →
{exprArgs : Array Lean.Expr} →
{newLocalDecls' localDecls' newLetDecls' : Array Lean.LocalDecl} →
{exprArgs' : Array Lean.Expr} →
{ newLocalDecls := newLocalDecls, localDecls := localDecls, newLetDecls := newLetDecls,
exprArgs := exprArgs } =
{ newLocalDecls := newLocalDecls', localDecls := localDecls', newLetDecls := newLetDecls',
exprArgs := exprArgs' } →
(newLocalDecls = newLocalDecls' →
localDecls = localDecls' → newLetDecls = newLetDecls' → exprArgs = exprArgs' → P) →
P | false |
HomotopicalAlgebra.mem_trivialCofibrations_iff | Mathlib.AlgebraicTopology.ModelCategory.CategoryWithCofibrations | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : HomotopicalAlgebra.CategoryWithCofibrations C] [inst_2 : HomotopicalAlgebra.CategoryWithWeakEquivalences C],
HomotopicalAlgebra.trivialCofibrations C f ↔ HomotopicalAlgebra.Cofibration f ∧ HomotopicalAlgebra.WeakEquivalence f | true |
instMetricSpaceEmpty._proof_2 | Mathlib.Topology.MetricSpace.Defs | ∀ (x y : Empty), 0 = ENNReal.ofReal 0 | false |
Lean.Elab.Tactic.BVDecide.Frontend.evalBvDecide._regBuiltin.Lean.Elab.Tactic.BVDecide.Frontend.evalBvDecide_1 | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide | IO Unit | false |
_private.Mathlib.LinearAlgebra.Matrix.Irreducible.Defs.0.Matrix.isIrreducible_transpose_iff._simp_1_3 | Mathlib.LinearAlgebra.Matrix.Irreducible.Defs | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | false |
Lean.Grind.LinarithConfig.mk.inj | Init.Grind.Config | ∀ {toNoopConfig toNoopConfig_1 : Lean.Grind.NoopConfig},
{ toNoopConfig := toNoopConfig } = { toNoopConfig := toNoopConfig_1 } → toNoopConfig = toNoopConfig_1 | true |
TendstoLocallyUniformlyOn.mul₀ | Mathlib.Topology.MetricSpace.Algebra | ∀ {X : Type u_3} {M : Type u_4} {ι : Type u_5} [inst : TopologicalSpace X] [inst_1 : PseudoMetricSpace M]
[inst_2 : Zero M] [inst_3 : Mul M] [IsBoundedSMul M M] {s : Set X} {F G : ι → X → M} {f g : X → M} {l : Filter ι},
TendstoLocallyUniformlyOn F f l s →
TendstoLocallyUniformlyOn G g l s →
ContinuousOn f s → ContinuousOn g s → TendstoLocallyUniformlyOn (F * G) (f * g) l s | true |
CategoryTheory.Limits.limit.post.eq_1 | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{D : Type u'} [inst_2 : CategoryTheory.Category.{v', u'} D] (F : CategoryTheory.Functor J C)
[inst_3 : CategoryTheory.Limits.HasLimit F] (G : CategoryTheory.Functor C D)
[inst_4 : CategoryTheory.Limits.HasLimit (F.comp G)],
CategoryTheory.Limits.limit.post F G =
CategoryTheory.Limits.limit.lift (F.comp G) (G.mapCone (CategoryTheory.Limits.limit.cone F)) | true |
Filter.pureMulHom | Mathlib.Order.Filter.Pointwise | {α : Type u_2} → [inst : Mul α] → α →ₙ* Filter α | true |
AnalyticWithinAt.mul | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {A : Type u_7} [inst_3 : NormedRing A] [inst_4 : NormedAlgebra 𝕜 A] {f g : E → A}
{s : Set E} {z : E}, AnalyticWithinAt 𝕜 f s z → AnalyticWithinAt 𝕜 g s z → AnalyticWithinAt 𝕜 (fun x => f x * g x) s z | true |
CategoryTheory.Pretriangulated.Triangle.π₁._proof_1 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ]
(X : CategoryTheory.Pretriangulated.Triangle C),
(CategoryTheory.CategoryStruct.id X).hom₁ = CategoryTheory.CategoryStruct.id X.obj₁ | false |
WithTop.tendsto_nhds_top_iff | Mathlib.Topology.Order.WithTop | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : TopologicalSpace ι] [inst_2 : OrderTopology ι] {α : Type u_2}
{f : Filter α} (x : α → WithTop ι), Filter.Tendsto x f (nhds ⊤) ↔ ∀ (i : ι), ∀ᶠ (a : α) in f, ↑i < x a | true |
CStarAlgebra.isUnit_of_le | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | ∀ {A : Type u_1} [inst : CStarAlgebra A] [inst_1 : PartialOrder A] [StarOrderedRing A] (a : A) {b : A},
a ≤ b → autoParam (IsStrictlyPositive a) CStarAlgebra.isUnit_of_le._auto_1 → IsUnit b | true |
unexpandSubtype | Init.NotationExtra | Lean.PrettyPrinter.Unexpander | true |
_private.Lean.Elab.Tactic.Grind.Lint.0.Lean.Elab.Tactic.Grind.mkParams | Lean.Elab.Tactic.Grind.Lint | Lean.Grind.Config → Lean.MetaM Lean.Meta.Grind.Params | true |
SimplexCategory.const_apply | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ (x y : SimplexCategory) (i : Fin (y.len + 1)) (a : Fin (x.len + 1)),
(SimplexCategory.Hom.toOrderHom (x.const y i)) a = i | true |
_private.Lean.Environment.0.Lean.Environment.PromiseCheckedResult.mk.inj | Lean.Environment | ∀ {mainEnv asyncEnv : Lean.Environment} {checkedEnvPromise : IO.Promise Lean.Kernel.Environment}
{mainEnv_1 asyncEnv_1 : Lean.Environment} {checkedEnvPromise_1 : IO.Promise Lean.Kernel.Environment},
{ mainEnv := mainEnv, asyncEnv := asyncEnv, checkedEnvPromise := checkedEnvPromise } =
{ mainEnv := mainEnv_1, asyncEnv := asyncEnv_1, checkedEnvPromise := checkedEnvPromise_1 } →
mainEnv = mainEnv_1 ∧ asyncEnv = asyncEnv_1 ∧ checkedEnvPromise = checkedEnvPromise_1 | true |
PredOrder.ofCore.eq_1 | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] (succ : α → α) (hn : ∀ {a : α}, ¬IsMin a → ∀ (b : α), b < a ↔ b ≤ succ a)
(hm : ∀ (a : α), IsMin a → succ a = a),
PredOrder.ofCore succ hn hm = { pred := succ, pred_le := ⋯, min_of_le_pred := ⋯, le_pred_of_lt := ⋯ } | true |
ModuleCat.limitModule._proof_8 | Mathlib.Algebra.Category.ModuleCat.Limits | ∀ {R : Type u_4} [inst : Ring R] {J : Type u_3} [inst_1 : CategoryTheory.Category.{u_1, u_3} J]
(F : CategoryTheory.Functor J (ModuleCat R))
[inst_2 : Small.{u_2, max u_3 u_2} ↑(F.comp (CategoryTheory.forget (ModuleCat R))).sections]
(x : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget (ModuleCat R)))).pt), 0 • x = 0 | false |
Mathlib.TacticAnalysis.Config.mk.noConfusion | Mathlib.Tactic.TacticAnalysis | {P : Sort u} →
{run run' : Array Mathlib.TacticAnalysis.TacticNode → Lean.Elab.Command.CommandElabM Unit} →
{ run := run } = { run := run' } → (run = run' → P) → P | false |
CategoryTheory.Limits.Concrete.widePullback_ext | Mathlib.CategoryTheory.Limits.Shapes.ConcreteCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type (max v w)}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC] {B : C}
{ι : Type w} {X : ι → C} (f : (j : ι) → X j ⟶ B) [inst_3 : CategoryTheory.Limits.HasWidePullback B X f]
[CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.WidePullbackShape.wideCospan B X f)
(CategoryTheory.forget C)]
(x y : CategoryTheory.ToType (CategoryTheory.Limits.widePullback B X f)),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.WidePullback.base f)) x =
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.WidePullback.base f)) y →
(∀ (j : ι),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.WidePullback.π f j)) x =
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.WidePullback.π f j)) y) →
x = y | true |
ProofWidgets.Penrose.RpcEncodablePacket.mk.«_@».ProofWidgets.Component.PenroseDiagram.3621647104._hygCtx._hyg.1.noConfusion | ProofWidgets.Component.PenroseDiagram | {P : Sort u} →
{embeds dsl sty sub maxOptSteps embeds' dsl' sty' sub' maxOptSteps' : Lean.Json} →
{ embeds := embeds, dsl := dsl, sty := sty, sub := sub, maxOptSteps := maxOptSteps } =
{ embeds := embeds', dsl := dsl', sty := sty', sub := sub', maxOptSteps := maxOptSteps' } →
(embeds = embeds' → dsl = dsl' → sty = sty' → sub = sub' → maxOptSteps = maxOptSteps' → P) → P | false |
_private.Mathlib.Tactic.CancelDenoms.Core.0.Mathlib.Tactic._aux_Mathlib_Tactic_CancelDenoms_Core___elabRules_Mathlib_Tactic_tacticCancel_denoms__1.match_1 | Mathlib.Tactic.CancelDenoms.Core | (motive : Option (Lean.TSyntax `Lean.Parser.Tactic.location) → Sort u_1) →
(loc? : Option (Lean.TSyntax `Lean.Parser.Tactic.location)) →
((loc? : Lean.TSyntax `Lean.Parser.Tactic.location) → motive (some loc?)) →
((x : Option (Lean.TSyntax `Lean.Parser.Tactic.location)) → motive x) → motive loc? | false |
CategoryTheory.SimplicialObject.augmentOfIsTerminal | Mathlib.AlgebraicTopology.SimplicialObject.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
CategoryTheory.SimplicialObject C →
{T : C} → CategoryTheory.Limits.IsTerminal T → CategoryTheory.SimplicialObject.Augmented C | true |
_private.Mathlib.CategoryTheory.Galois.Prorepresentability.0.CategoryTheory.PreGaloisCategory.AutGalois.π_surjective._proof_1_1 | Mathlib.CategoryTheory.Galois.Prorepresentability | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.GaloisCategory C]
(F : CategoryTheory.Functor C FintypeCat) (i : CategoryTheory.PreGaloisCategory.PointedGaloisObject F),
Finite (((CategoryTheory.PreGaloisCategory.autGaloisSystem F).comp (CategoryTheory.forget GrpCat)).obj i) | false |
Mathlib.Deriving.Encodable.mkEncodableInstance | Mathlib.Tactic.DeriveEncodable | Array Lean.Name → Lean.Elab.Command.CommandElabM Bool | true |
Array.scanl_singleton | Batteries.Data.Array.Scan | ∀ {β : Type u_1} {α : Type u_2} {init : β} {a : α} {f : β → α → β}, Array.scanl f init #[a] = #[init, f init a] | true |
Bundle.Trivialization.proj_surjOn_baseSet | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (e : Bundle.Trivialization F proj) [Nonempty F], Set.SurjOn proj e.source e.baseSet | true |
Std.DHashMap.Internal.Raw₀.Const.mem_toArray_iff_get?_eq_some | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[LawfulBEq α],
(↑m).WF →
∀ {k : α} {v : β}, (k, v) ∈ Std.DHashMap.Raw.Const.toArray ↑m ↔ Std.DHashMap.Internal.Raw₀.Const.get? m k = some v | true |
HomotopicalAlgebra.Precylinder.LeftHomotopy.refl_h | Mathlib.AlgebraicTopology.ModelCategory.LeftHomotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (P : HomotopicalAlgebra.Precylinder X) {Y : C}
(f : X ⟶ Y), (HomotopicalAlgebra.Precylinder.LeftHomotopy.refl P f).h = CategoryTheory.CategoryStruct.comp P.π f | true |
_private.Init.Ext.0.PProd.ext.match_1 | Init.Ext | ∀ {α : Sort u_1} {β : Sort u_2} (motive : α ×' β → Prop) (h : α ×' β),
(∀ (fst : α) (snd : β), motive ⟨fst, snd⟩) → motive h | false |
WellFounded.prop_min | Mathlib.Order.WellFounded | ∀ {α : Type u_1} {r : α → α → Prop} (H : WellFounded r) {p : α → Prop} (h : ∃ a, p a), p (H.min {a | p a} h) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.