name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Meta.instInhabitedUnificationHintEntry | Lean.Meta.UnificationHint | Inhabited Lean.Meta.UnificationHintEntry | true |
BitVec.Literal.noConfusion | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | {P : Sort u} → {t t' : BitVec.Literal} → t = t' → BitVec.Literal.noConfusionType P t t' | false |
Complex.two_sin | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℂ), 2 * Complex.sin x = (Complex.exp (-x * Complex.I) - Complex.exp (x * Complex.I)) * Complex.I | true |
IsCompact.isClosed | Mathlib.Topology.Separation.Hausdorff | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T2Space X] {s : Set X}, IsCompact s → IsClosed s | true |
Lean.RBMap.foldM | Lean.Data.RBMap | {α : Type u} →
{β : Type v} →
{σ : Type w} →
{cmp : α → α → Ordering} → {m : Type w → Type u_1} → [Monad m] → (σ → α → β → m σ) → σ → Lean.RBMap α β cmp → m σ | true |
CategoryTheory.GrothendieckTopology.instFaithfulSheafTypeUliftYoneda | Mathlib.CategoryTheory.Sites.Canonical | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C)
[inst_1 : J.Subcanonical], (CategoryTheory.GrothendieckTopology.uliftYoneda.{w, v, u} J).Faithful | true |
WType.noConfusion | Mathlib.Data.W.Basic | {P : Sort u} →
{α : Type u_1} →
{β : α → Type u_2} →
{t : WType β} →
{α' : Type u_1} →
{β' : α' → Type u_2} → {t' : WType β'} → α = α' → β ≍ β' → t ≍ t' → WType.noConfusionType P t t' | false |
ZFSet.rank_iUnion | Mathlib.SetTheory.ZFC.Rank | ∀ {α : Type u_1} [inst : Small.{u, u_1} α] (f : α → ZFSet.{u}), (ZFSet.iUnion fun i => f i).rank = ⨆ i, (f i).rank | true |
List.length_pos_of_sum_ne_zero | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {M : Type u_4} [inst : AddMonoid M] (L : List M), L.sum ≠ 0 → 0 < L.length | true |
Lean.Core.CoreM.parFirst | Lean.Elab.Parallel | {α : Type} → List (Lean.CoreM α) → optParam Bool true → Lean.CoreM α | true |
CategoryTheory.Functor.CommShift.ofHasShiftOfFullyFaithful._proof_2 | Mathlib.CategoryTheory.Shift.CommShift | ∀ {C : Type u_1} {D : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] {A : Type u_5} [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift D A] {F : CategoryTheory.Functor C D} (hF : F.FullyFaithful)
(s : A → CategoryTheory.Functor C C) (i : (i : A) → (s ... | false |
_private.Mathlib.RingTheory.WittVector.MulP.0.WittVector._aux_Mathlib_RingTheory_WittVector_MulP___unexpand_WittVector_1 | Mathlib.RingTheory.WittVector.MulP | Lean.PrettyPrinter.Unexpander | false |
CochainComplex.mappingCocone.inl_v_desc_f | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} (φ : K ⟶ L) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {M : CochainComplex C ℤ}
(α : CochainComplex.HomComplex.Cochain K M 0) (β : CochainComplex.HomComplex.Cocycle L M 1)
(hαβ... | true |
Array.toList_zip | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {ys : Array β}, (xs.zip ys).toList = xs.toList.zip ys.toList | true |
GenLoop.instContinuousEval | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {x : X},
ContinuousEval (↑(GenLoop N X x)) (N → ↑unitInterval) X | true |
StarSubalgebra.mem_toNonUnitalStarSubalgebra._simp_1 | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : StarRing A] [inst_4 : Algebra R A] [inst_5 : StarModule R A] {S : StarSubalgebra R A} {x : A},
(x ∈ S.toNonUnitalStarSubalgebra) = (x ∈ S) | false |
MeasureTheory.SignedMeasure.rnDeriv_def | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} (s : MeasureTheory.SignedMeasure α) (μ : MeasureTheory.Measure α),
s.rnDeriv μ = fun x =>
(s.toJordanDecomposition.posPart.rnDeriv μ x).toReal - (s.toJordanDecomposition.negPart.rnDeriv μ x).toReal | true |
ContinuousMap.toAEEqFunMulHom.eq_1 | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α) [inst_1 : TopologicalSpace α]
[inst_2 : BorelSpace α] [inst_3 : TopologicalSpace β] [inst_4 : SecondCountableTopologyEither α β]
[inst_5 : TopologicalSpace.PseudoMetrizableSpace β] [inst_6 : Group β] [inst_7 : IsTopologicalGrou... | true |
CategoryTheory.PrelaxFunctorStruct | Mathlib.CategoryTheory.Bicategory.Functor.Prelax | (B : Type u₁) →
[inst : Quiver B] →
[(a b : B) → Quiver (a ⟶ b)] →
(C : Type u₂) →
[inst : Quiver C] → [(a b : C) → Quiver (a ⟶ b)] → Type (max (max (max (max (max u₁ u₂) v₁) v₂) w₁) w₂) | true |
IsCompact.closure | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [R1Space X] {K : Set X}, IsCompact K → IsCompact (closure K) | true |
_private.Aesop.Tree.ExtractProof.0.Aesop.extractProofGoal.match_1 | Aesop.Tree.ExtractProof | (motive : Option Aesop.RappRef → Sort u_1) →
(rref? : Option Aesop.RappRef) →
((rref : Aesop.RappRef) → motive (some rref)) → ((x : Option Aesop.RappRef) → motive x) → motive rref? | false |
_private.Mathlib.Analysis.Calculus.ContDiff.Convolution.0.MeasureTheory.hasFDerivAt_convolution_right_with_param._simp_1_1 | Mathlib.Analysis.Calculus.ContDiff.Convolution | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | false |
Matrix.blockDiagonalRingHom._proof_1 | Mathlib.Data.Matrix.Block | ∀ (m : Type u_2) (o : Type u_3) (α : Type u_1) [inst : DecidableEq o] [inst_1 : DecidableEq m]
[inst_2 : NonAssocSemiring α], Matrix.blockDiagonal 1 = 1 | false |
ContinuousAlternatingMap.toAlternatingMap_zero | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {ι : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N], ContinuousAlternatingMap.toAlternatingMap 0 = 0 | true |
_private.Mathlib.MeasureTheory.Group.FundamentalDomain.0.MeasureTheory.termα_mod_G_2 | Mathlib.MeasureTheory.Group.FundamentalDomain | Lean.ParserDescr | true |
WCovBy._to_dual_cast_4 | Mathlib.Order.Defs.PartialOrder | ∀ {α : Type u_1} [inst : Preorder α] (a b : α), (b ⩿ a) = (b ≤ a ∧ ∀ ⦃c : α⦄, c < a → ¬b < c) | false |
Lean.Lsp.FoldingRange.kind? | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.FoldingRange → Option Lean.Lsp.FoldingRangeKind | true |
TopologicalSpace.Compacts.equiv._proof_3 | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : α ≃ₜ β)
(s : TopologicalSpace.Compacts α), TopologicalSpace.Compacts.map ⇑f.symm ⋯ (TopologicalSpace.Compacts.map ⇑f ⋯ s) = s | false |
Lean.writeModule | Lean.Environment | Lean.Environment → System.FilePath → IO Unit | true |
instRingFreeRing._proof_16 | Mathlib.RingTheory.FreeRing | ∀ (α : Type u_1) (a b c : FreeRing α), (a + b) * c = a * c + b * c | false |
AddMonCat.uliftFunctor._proof_1 | Mathlib.Algebra.Category.MonCat.Basic | ∀ (X : AddMonCat),
AddMonCat.ofHom
(AddEquiv.ulift.symm.toAddMonoidHom.comp
((AddMonCat.Hom.hom (CategoryTheory.CategoryStruct.id X)).comp AddEquiv.ulift.toAddMonoidHom)) =
CategoryTheory.CategoryStruct.id (AddMonCat.of (ULift.{u_1, u_2} ↑X)) | false |
Lean.Parser.checkColEq | Lean.Parser.Basic | optParam String "checkColEq" → Lean.Parser.Parser | true |
Subgroup.IsComplement.quotientGroupMk_leftQuotientEquiv | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} {S : Set G} (hS : Subgroup.IsComplement S ↑H) (q : G ⧸ H),
Quotient.mk'' ↑(hS.leftQuotientEquiv q) = q | true |
Lean.PrettyPrinter.Delaborator.State.holeIter | Lean.PrettyPrinter.Delaborator.Basic | Lean.PrettyPrinter.Delaborator.State → Lean.PrettyPrinter.Delaborator.SubExpr.HoleIterator | true |
ContinuousAt.zpow | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : Group G] [IsTopologicalGroup G]
[inst_3 : TopologicalSpace α] {f : α → G} {x : α}, ContinuousAt f x → ∀ (z : ℤ), ContinuousAt (fun x => f x ^ z) x | true |
Part.some_mul_some | Mathlib.Data.Part | ∀ {α : Type u_1} [inst : Mul α] (a b : α), Part.some a * Part.some b = Part.some (a * b) | true |
_private.Lean.Elab.DocString.0.Lean.Doc.getFlag.match_3 | Lean.Elab.DocString | (motive : Option Bool → Sort u_1) → (x : Option Bool) → (Unit → motive none) → ((a : Bool) → motive (some a)) → motive x | false |
Finset.mem_nonMemberSubfamily | Mathlib.Combinatorics.SetFamily.Compression.Down | ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Finset (Finset α)} {s : Finset α} {a : α},
s ∈ Finset.nonMemberSubfamily a 𝒜 ↔ s ∈ 𝒜 ∧ a ∉ s | true |
Lean.Grind.CommRing.Mon.collectVars._sunfold | Lean.Meta.Tactic.Grind.Arith.CommRing.VarRename | Lean.Grind.CommRing.Mon → Lean.Meta.Grind.VarCollector | false |
AlgebraicGeometry.isIso_fromTildeΓ_iff | Mathlib.AlgebraicGeometry.Modules.Tilde | ∀ {R : CommRingCat} {M : (AlgebraicGeometry.Spec R).Modules},
CategoryTheory.IsIso M.fromTildeΓ ↔ (AlgebraicGeometry.tilde.functor R).essImage M | true |
_private.Mathlib.Order.Compare.0.Ordering.Compares.le_antisymm.match_1_1 | Mathlib.Order.Compare | ∀ {α : Type u_1} [inst : Preorder α] {a b : α} (motive : (x : Ordering) → x.Compares a b → a ≤ b → b ≤ a → Prop)
(x : Ordering) (x_1 : x.Compares a b) (x_2 : a ≤ b) (x_3 : b ≤ a),
(∀ (h : Ordering.lt.Compares a b) (x : a ≤ b) (hba : b ≤ a), motive Ordering.lt h x hba) →
(∀ (h : Ordering.eq.Compares a b) (x : a ... | false |
BddLat.Hom.noConfusion | Mathlib.Order.Category.BddLat | {P : Sort u_1} →
{X Y : BddLat} →
{t : X.Hom Y} → {X' Y' : BddLat} → {t' : X'.Hom Y'} → X = X' → Y = Y' → t ≍ t' → BddLat.Hom.noConfusionType P t t' | false |
CategoryTheory.InjectiveResolution.ι_f_zero_comp_complex_d_assoc | Mathlib.CategoryTheory.Preadditive.Injective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (I : CategoryTheory.InjectiveResolution Z) {Z_1 : C}
(h : I.cocomplex.X 1 ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (I.ι.f 0) (CategoryTheory.Categ... | true |
Lean.Meta.Simp.userPostDSimprocs | Lean.Meta.Tactic.Simp.Simproc | Lean.Meta.Simp.SimprocsArray → Lean.Meta.Simp.DSimproc | true |
MeasureTheory.«_aux_Mathlib_Analysis_LConvolution___macroRules_MeasureTheory_term_⋆ₗ[_]__1» | Mathlib.Analysis.LConvolution | Lean.Macro | false |
fderiv_inv' | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {R : Type u_5} [inst_1 : NormedDivisionRing R]
[inst_2 : NormedAlgebra 𝕜 R] {x : R}, x ≠ 0 → fderiv 𝕜 Inv.inv x = -((ContinuousLinearMap.mulLeftRight 𝕜 R) x⁻¹) x⁻¹ | true |
Std.DTreeMap.Internal.Impl.mem_insertMany!_list._simp_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α] [inst : BEq α]
[Std.LawfulBEqOrd α],
t.WF →
∀ {l : List ((a : α) × β a)} {k : α}, (k ∈ ↑(t.insertMany! l)) = (k ∈ t ∨ (List.map Sigma.fst l).contains k = true) | false |
SimpleGraph.Walk.isTrail_cons._simp_1 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u v w : V} (h : G.Adj u v) (p : G.Walk v w),
(SimpleGraph.Walk.cons h p).IsTrail = (p.IsTrail ∧ s(u, v) ∉ p.edges) | false |
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs_sub._proof_1_38 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α) {i : ℕ} (s : ℕ),
i < (List.filter p (head :: tail)).length → ¬p head = true → i < (List.findIdxs p tail (s + 1)).length | false |
Prod.RProdSubLex | Init.WF | ∀ {α : Type u} {β : Type v} {ra : α → α → Prop} {rb : β → β → Prop} (a b : α × β),
Prod.RProd ra rb a b → Prod.Lex ra rb a b | true |
DoubleCentralizer.add_fst | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : NormedSpace 𝕜 A] [inst_3 : SMulCommClass 𝕜 A A] [inst_4 : IsScalarTower 𝕜 A A]
(a b : DoubleCentralizer 𝕜 A), (a + b).toProd.1 = a.toProd.1 + b.toProd.1 | true |
ContinuousLinearMap.prodₗᵢ.match_1 | Mathlib.Analysis.Normed.Operator.Prod | ∀ {𝕜 : Type u_4} {E : Type u_2} {F : Type u_1} {G : Type u_3} [inst : NontriviallyNormedField 𝕜]
[inst_1 : SeminormedAddCommGroup E] [inst_2 : SeminormedAddCommGroup F] [inst_3 : SeminormedAddCommGroup G]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜 F] [inst_6 : NormedSpace 𝕜 G]
(motive : (E →L[𝕜] F) ... | false |
Std.TreeSet.forM_eq_forM | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m]
{f : α → m PUnit.{w + 1}}, Std.TreeSet.forM f t = forM t f | true |
FirstOrder.Language.BoundedFormula.IsUniversal.below.rec | Mathlib.ModelTheory.Complexity | ∀ {L : FirstOrder.Language} {α : Type u'} {motive : {n : ℕ} → (a : L.BoundedFormula α n) → a.IsUniversal → Prop}
{motive_1 :
{n : ℕ} →
{a : L.BoundedFormula α n} → (t : a.IsUniversal) → FirstOrder.Language.BoundedFormula.IsUniversal.below t → Prop},
(∀ {n : ℕ} {φ : L.BoundedFormula α n} (h : φ.IsQF), moti... | false |
_private.Batteries.Data.Fin.Lemmas.0.Fin.bind_findSome?_guard_isSome._simp_1_2 | Batteries.Data.Fin.Lemmas | ∀ {α : Type u_1} {b : α} {α_1 : Type u_2} {x : Option α_1} {f : α_1 → Option α},
(x.bind f = some b) = ∃ a, x = some a ∧ f a = some b | false |
Std.Rxi.LawfulHasSize.ofMap | Init.Data.Range.Polymorphic.Map | ∀ {α : Type u_1} {β : Type u_2} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.UpwardEnumerable β]
[inst_2 : Std.Rxi.HasSize α] [inst_3 : Std.Rxi.HasSize β] [Std.Rxi.LawfulHasSize β]
(f : Std.PRange.UpwardEnumerable.Map α β) [f.PreservesRxiSize], Std.Rxi.LawfulHasSize α | true |
ENNReal.powOrderIso._proof_2 | Mathlib.Topology.Instances.NNReal.Lemmas | ∀ (n : ℕ) (hn : n ≠ 0),
⇑(RelIso.symm (NNReal.powOrderIso n hn).withTopCongr) = ⇑(RelIso.symm (NNReal.powOrderIso n hn).withTopCongr) | false |
Lean.Omega.positivize.eq_1 | Init.Omega.Constraint | ∀ (p : Lean.Omega.Constraint × Lean.Omega.Coeffs), Lean.Omega.positivize p = (Lean.Omega.positivize? p).getD p | true |
InfSet.mk.noConfusion | Mathlib.Order.SetNotation | {α : Type u_1} → {P : Sort u} → {sInf sInf' : Set α → α} → { sInf := sInf } = { sInf := sInf' } → (sInf ≍ sInf' → P) → P | false |
CategoryTheory.Limits.Concrete.productEquiv_apply_apply | Mathlib.CategoryTheory.Limits.Shapes.ConcreteCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type (max w v)}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC] {J : Type w}
(F : J → C) [inst_3 : CategoryTheory.Limits.HasProduct F]
[inst_4 : CategoryTheory.Limits.Pr... | true |
Std.Rii.forIn'_eq_forIn'_toList | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rii α} [inst : Std.PRange.Least? α] [inst_1 : Std.PRange.UpwardEnumerable α]
[inst_2 : Std.PRange.LawfulUpwardEnumerableLeast? α] [inst_3 : Std.Rxi.IsAlwaysFinite α]
[inst_4 : Std.PRange.LawfulUpwardEnumerable α] {γ : Type u} {init : γ} {m : Type u → Type w} [inst_5 : Monad m]
[LawfulMonad... | true |
Subgroup.disjoint_map | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] {f : G →* N},
Function.Injective ⇑f → ∀ {H K : Subgroup G}, Disjoint H K → Disjoint (Subgroup.map f H) (Subgroup.map f K) | true |
_private.Lean.Elab.AssertExists.0.Lean.Environment.importPath.match_1 | Lean.Elab.AssertExists | (motive : MProd (Array Lean.Name) Lean.Name → Sort u_1) →
(r : MProd (Array Lean.Name) Lean.Name) →
((result : Array Lean.Name) → (target : Lean.Name) → motive ⟨result, target⟩) → motive r | false |
MeasureTheory.map_trim_comap | Mathlib.MeasureTheory.Measure.Trim | ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} {mβ : MeasurableSpace β} {μ : MeasureTheory.Measure α}
{f : α → β} (hf : Measurable f), MeasureTheory.Measure.map f (μ.trim ⋯) = MeasureTheory.Measure.map f μ | true |
AddMonoidAlgebra.coe_liftNCAlgHom | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_1} {A : Type u_4} {B : Type u_5} {M : Type u_7} [inst : CommSemiring R] [inst_1 : AddMonoid M]
[inst_2 : Semiring A] [inst_3 : Algebra R A] [inst_4 : Semiring B] [inst_5 : Algebra R B] (f : A →ₐ[R] B)
(g : Multiplicative M →* B) (h_comm : ∀ (x : A) (y : Multiplicative M), Commute (f x) (g y)),
⇑(Add... | true |
_private.Mathlib.Analysis.CStarAlgebra.CStarMatrix.0.CStarMatrix.normedSpaceAux | Mathlib.Analysis.CStarAlgebra.CStarMatrix | {m : Type u_1} →
{n : Type u_2} →
{A : Type u_3} →
[inst : Fintype m] →
[inst_1 : Fintype n] →
[inst_2 : NonUnitalCStarAlgebra A] →
[inst_3 : PartialOrder A] → [inst_4 : StarOrderedRing A] → NormedSpace ℂ (CStarMatrix m n A) | true |
Array.getElem_attachWith._proof_1 | Init.Data.Array.Attach | ∀ {α : Type u_1} {xs : Array α} {P : α → Prop} {H : ∀ a ∈ xs, P a} {i : ℕ}, i < (xs.attachWith P H).size → i < xs.size | false |
Lean.mkNatMul | Lean.Expr | Lean.Expr → Lean.Expr → Lean.Expr | true |
ISize.zero_add | Init.Data.SInt.Lemmas | ∀ (a : ISize), 0 + a = a | true |
AddSubgroup.mem_map_iff_mem._simp_1 | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] {f : G →+ N},
Function.Injective ⇑f → ∀ {K : AddSubgroup G} {x : G}, (f x ∈ AddSubgroup.map f K) = (x ∈ K) | false |
List.tailD | Init.Data.List.Basic | {α : Type u} → List α → List α → List α | true |
Filter.Tendsto.eventually_lt_const | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} {γ : Type w} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [ClosedIciTopology α] {l : Filter γ}
{f : γ → α} {u v : α}, v < u → Filter.Tendsto f l (nhds v) → ∀ᶠ (a : γ) in l, f a < u | true |
StrictMono.const_nsmul | Mathlib.Algebra.Order.Monoid.Unbundled.Pow | ∀ {β : Type u_1} {M : Type u_3} [inst : AddMonoid M] [inst_1 : Preorder M] [inst_2 : Preorder β] [AddLeftStrictMono M]
[AddRightStrictMono M] {f : β → M}, StrictMono f → ∀ {n : ℕ}, n ≠ 0 → StrictMono fun x => n • f x | true |
Lean.NameMap.filter | Lean.Data.NameMap.Basic | {α : Type} → (Lean.Name → α → Bool) → Lean.NameMap α → Lean.NameMap α | true |
MonCat.one_of | Mathlib.Algebra.Category.MonCat.Basic | ∀ {A : Type u_1} [inst : Monoid A], 1 = 1 | true |
_private.Mathlib.GroupTheory.Commutator.Basic.0.Subgroup.commutator_normal._simp_1 | Mathlib.GroupTheory.Commutator.Basic | ∀ {G : Type u_1} [inst : Group G] {s : Set G} {x : G}, (x ∈ Group.conjugatesOfSet s) = ∃ a ∈ s, IsConj a x | false |
StrictConcaveOn.strictAntiOn_derivWithin | Mathlib.Analysis.Convex.Deriv | ∀ {S : Set ℝ} {f : ℝ → ℝ}, StrictConcaveOn ℝ S f → DifferentiableOn ℝ f S → StrictAntiOn (derivWithin f S) S | true |
HomogeneousLocalization.NumDenSameDeg.instMul._proof_2 | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {ι : Type u_3} {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A]
[inst_2 : AddSubmonoidClass σ A] {𝒜 : ι → σ} (x : Submonoid A) [inst_3 : AddCommMonoid ι] [inst_4 : DecidableEq ι]
[GradedRing 𝒜] (p q : HomogeneousLocalization.NumDenSameDeg 𝒜 x), ↑p.den * ↑q.den ∈ 𝒜 (p.deg + q.deg) | false |
_private.Mathlib.RingTheory.Localization.Integral.0.IsLocalization.exists_isIntegral_smul_of_isIntegral_map._simp_1_3 | Mathlib.RingTheory.Localization.Integral | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] {f : F} {S : Submonoid M} {y : N}, (y ∈ Submonoid.map f S) = ∃ x ∈ S, f x = y | false |
Fin.exists_succ_eq_of_ne_zero | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} {x : Fin (n + 1)}, x ≠ 0 → ∃ y, y.succ = x | true |
CategoryTheory.MonoidalCategory.ofTensorHom._auto_11 | Mathlib.CategoryTheory.Monoidal.Category | Lean.Syntax | false |
gauge_le_eq | Mathlib.Analysis.Convex.Gauge | ∀ {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module ℝ E] {s : Set E} {a : ℝ},
Convex ℝ s → 0 ∈ s → Absorbent ℝ s → 0 ≤ a → {x | gauge s x ≤ a} = ⋂ r, ⋂ (_ : a < r), r • s | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Basic.0.Std.Tactic.BVDecide.BVExpr.toString.match_1.eq_8 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ (motive : (w : ℕ) → Std.Tactic.BVDecide.BVExpr w → Sort u_1) (w n : ℕ) (lhs : Std.Tactic.BVDecide.BVExpr w)
(rhs : Std.Tactic.BVDecide.BVExpr n) (h_1 : (w idx : ℕ) → motive w (Std.Tactic.BVDecide.BVExpr.var idx))
(h_2 : (w : ℕ) → (val : BitVec w) → motive w (Std.Tactic.BVDecide.BVExpr.const val))
(h_3 :
(le... | true |
List.findIdxNth_eq_findIdxNth_iff_of_left_lt_countP | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {n : ℕ} {p : α → Bool} {m : ℕ} {xs : List α},
n < List.countP p xs → (List.findIdxNth p xs n = List.findIdxNth p xs m ↔ n = m) | true |
_private.Mathlib.Data.Finset.Order.0.Directed.finset_le.match_1_3 | Mathlib.Data.Finset.Order | ∀ {α : Type u_2} {r : α → α → Prop} {ι : Type u_1} {f : ι → α} (i j : ι)
(motive : (∃ z, r (f i) (f z) ∧ r (f j) (f z)) → Prop) (x : ∃ z, r (f i) (f z) ∧ r (f j) (f z)),
(∀ (k : ι) (h₁ : r (f i) (f k)) (h₂ : r (f j) (f k)), motive ⋯) → motive x | false |
Lean.Meta.Grind.DelayedTheoremInstance.mk._flat_ctor | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.EMatchTheorem →
Lean.Expr → Lean.Expr → ℕ → List Lean.Meta.Grind.TheoremGuard → Lean.Meta.Grind.DelayedTheoremInstance | false |
_private.Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence.0.CategoryTheory.Abelian.SpectralObject.coreE₂CohomologicalFin._proof_16 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (l : ℕ) (r a₁ : ℤ) (a₂ : ℕ) (isLt : a₂ < l) (b₁ : ℤ) (b₂ : ℕ) (isLt_1 : b₂ < l),
(a₁, ⟨a₂, isLt⟩).1 + (r, 1 - r).1 = (b₁, ⟨b₂, isLt_1⟩).1 →
↑↑(a₁, ⟨a₂, isLt⟩).2 + (r, 1 - r).2 = ↑↑(b₁, ⟨b₂, isLt_1⟩).2 →
∀ (hr : autoParam (2 ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_16),
... | false |
StarMul.casesOn | Mathlib.Algebra.Star.Basic | {R : Type u} →
[inst : Mul R] →
{motive : StarMul R → Sort u_1} →
(t : StarMul R) →
([toInvolutiveStar : InvolutiveStar R] →
(star_mul : ∀ (r s : R), star (r * s) = star s * star r) →
motive { toInvolutiveStar := toInvolutiveStar, star_mul := star_mul }) →
motive ... | false |
CategoryTheory.BicartesianSq | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.BicartesianSq | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] → {W X Y Z : C} → (W ⟶ X) → (W ⟶ Y) → (X ⟶ Z) → (Y ⟶ Z) → Prop | true |
Lean.Compiler.LCNF.Code.return.sizeOf_spec | Lean.Compiler.LCNF.Basic | ∀ {pu : Lean.Compiler.LCNF.Purity} (fvarId : Lean.FVarId),
sizeOf (Lean.Compiler.LCNF.Code.return fvarId) = 1 + sizeOf fvarId | true |
CategoryTheory.Functor.category._proof_2 | Mathlib.CategoryTheory.Functor.Category | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {X Y : CategoryTheory.Functor C D} (f : CategoryTheory.NatTrans X Y),
(CategoryTheory.NatTrans.id X).vcomp f = f | false |
CategoryTheory.Over.liftCone_π_app | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {J : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} J] (D : CategoryTheory.Functor J T) {X : T}
(s : D ⟶ (CategoryTheory.Functor.const J).obj X) (c : CategoryTheory.Limits.Cone D) (p : c.pt ⟶ X)
(hp : ∀ (j : J), CategoryTheory.CategoryStruct.comp... | true |
Finset.dens_pos | Mathlib.Data.Finset.Density | ∀ {α : Type u_2} [inst : Fintype α] {s : Finset α}, 0 < s.dens ↔ s.Nonempty | true |
_private.Mathlib.Geometry.Manifold.Instances.Sphere.0.stereo_right_inv._simp_1_9 | Mathlib.Geometry.Manifold.Instances.Sphere | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | false |
ContinuousLinearEquiv.toSpanNonzeroSingleton._proof_4 | Mathlib.Analysis.Normed.Module.Span | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] (x : E), x ≠ 0 → 0 < ‖x‖ | false |
DirectSum.Decomposition.ofLinearMap._proof_1 | Mathlib.Algebra.DirectSum.Decomposition | ∀ {R : Type u_1} [inst : Semiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | false |
_private.Lean.Linter.Deprecated.0.Lean.Linter.checkDeprecated._proof_1 | Lean.Linter.Deprecated | ∀ (newName : Lean.Name), newName.getPrefix.componentsRev.length > 1 → 0 < newName.getPrefix.componentsRev.length | false |
Batteries.RBNode.forIn.visit.eq_2 | Batteries.Data.RBMap.Lemmas | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {σ : Type u_1} [inst : Monad m] (f : α → σ → m (ForInStep σ)) (x : σ)
(c : Batteries.RBColor) (l : Batteries.RBNode α) (v : α) (r : Batteries.RBNode α),
Batteries.RBNode.forIn.visit f (Batteries.RBNode.node c l v r) x =
ForInStep.bindM (Batteries.RBNode.forIn.visit f l... | true |
Equiv.restrictPreimageFinset._proof_4 | Mathlib.Data.Finset.Preimage | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) (s : Finset β) (x : ↥s),
(fun a => ⟨e ↑a, ⋯⟩) ((fun b => ⟨e.symm ↑b, ⋯⟩) x) = x | false |
LinearPMap.neg_graph | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_4} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_5}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] (f : E →ₗ.[R] F),
(-f).graph = Submodule.map (LinearMap.id.prodMap (-LinearMap.id)) f.graph | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.