name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Nat.pred_eq_succ_iff._simp_1 | Init.Data.Nat.Lemmas | ∀ {n m : ℕ}, (n - 1 = m + 1) = (n = m + 2) | false |
Lean.Meta.Grind.SplitStatus.resolved.sizeOf_spec | Lean.Meta.Tactic.Grind.Split | sizeOf Lean.Meta.Grind.SplitStatus.resolved = 1 | true |
Array.scanr | Batteries.Data.Array.Basic | {α : Type u_1} → {β : Type u_2} → (α → β → β) → β → (as : Array α) → optParam ℕ as.size → optParam ℕ 0 → Array β | true |
_private.Mathlib.GroupTheory.FiniteIndexNormalSubgroup.0.FiniteIndexNormalAddSubgroup.ext.match_1 | Mathlib.GroupTheory.FiniteIndexNormalSubgroup | ∀ {G : Type u_1} {inst : AddGroup G} (motive : FiniteIndexNormalAddSubgroup G → Prop)
(h : FiniteIndexNormalAddSubgroup G),
(∀ (carrier : Set G) (add_mem' : ∀ {a b : G}, a ∈ carrier → b ∈ carrier → a + b ∈ carrier) (zero_mem' : 0 ∈ carrier)
(neg_mem' : ∀ {x : G}, x ∈ carrier → -x ∈ carrier)
(isNormal' :... | false |
_private.Mathlib.Topology.Order.LeftRightNhds.0.TFAE_mem_nhdsGT.match_1_1 | Mathlib.Topology.Order.LeftRightNhds | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α} (s : Set α) (motive : (∃ u ∈ Set.Ioc a b, Set.Ioo a u ⊆ s) → Prop)
(x : ∃ u ∈ Set.Ioc a b, Set.Ioo a u ⊆ s),
(∀ (u : α) (umem : u ∈ Set.Ioc a b) (hu : Set.Ioo a u ⊆ s), motive ⋯) → motive x | false |
IsIntegralClosure.module_free | Mathlib.RingTheory.DedekindDomain.IntegralClosure | ∀ (A : Type u_1) (K : Type u_2) [inst : CommRing A] [inst_1 : Field K] [inst_2 : Algebra A K] [IsFractionRing A K]
(L : Type u_3) [inst_4 : Field L] (C : Type u_4) [inst_5 : CommRing C] [inst_6 : Algebra K L] [inst_7 : Algebra A L]
[IsScalarTower A K L] [inst_9 : Algebra C L] [IsIntegralClosure C A L] [inst_11 : Al... | true |
Std.TreeMap.minKey_insertIfNew_le_minKey | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α} {v : β}
{he : t.isEmpty = false}, (cmp ((t.insertIfNew k v).minKey ⋯) (t.minKey he)).isLE = true | true |
Submonoid.apply_coe_mem_map | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {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) (x : ↥S), f ↑x ∈ Submonoid.map f S | true |
Option.traverse | Mathlib.Data.Option.Defs | {F : Type u → Type v} → [Applicative F] → {α : Type u_1} → {β : Type u} → (α → F β) → Option α → F (Option β) | true |
zpow_natCast_sub_natCast | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] (a : G) (m n : ℕ), a ^ (↑m - ↑n) = a ^ m / a ^ n | true |
Lean.Compiler.LCNF.Pass.phaseInv._autoParam | Lean.Compiler.LCNF.PassManager | Lean.Syntax | false |
DFA.reindex_apply_accept | Mathlib.Computability.DFA | ∀ {α : Type u} {σ : Type v} {σ' : Type u_2} (g : σ ≃ σ') (M : DFA α σ),
((DFA.reindex g) M).accept = ⇑g.symm ⁻¹' M.accept | true |
DividedPowers.RatAlgebra.dpow.eq_1 | Mathlib.RingTheory.DividedPowers.RatAlgebra | ∀ {R : Type u_1} [inst : CommSemiring R] (I : Ideal R) [inst_1 : DecidablePred fun x => x ∈ I],
DividedPowers.RatAlgebra.dpow I = DividedPowers.OfInvertibleFactorial.dpow I | true |
ProbabilityTheory.IndepFun_iff | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {x : MeasurableSpace Ω} {β : Type u_7} {γ : Type u_8} [mβ : MeasurableSpace β] [mγ : MeasurableSpace γ]
(f : Ω → β) (g : Ω → γ) (μ : MeasureTheory.Measure Ω),
ProbabilityTheory.IndepFun f g μ ↔ ∀ (t1 t2 : Set Ω), MeasurableSet t1 → MeasurableSet t2 → μ (t1 ∩ t2) = μ t1 * μ t2 | true |
IO.AsyncList.nil | Lean.Server.AsyncList | {ε : Type u} → {α : Type v} → IO.AsyncList ε α | true |
_private.Mathlib.Algebra.Algebra.Subalgebra.Lattice.0.Algebra.surjective_algebraMap_iff.match_1_1 | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (y : A)
(motive : (∃ a, (algebraMap R A) a = y) → Prop) (x : ∃ a, (algebraMap R A) a = y),
(∀ (_x : R) (hx : (algebraMap R A) _x = y), motive ⋯) → motive x | false |
Submodule.mapHom_apply | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : CommSemiring R] {A : Type v} [inst_1 : Semiring A] [inst_2 : Algebra R A] {A' : Type u_1}
[inst_3 : Semiring A'] [inst_4 : Algebra R A'] (f : A →ₐ[R] A') (p : Submodule R A),
(Submodule.mapHom f) p = Submodule.map f.toLinearMap p | true |
FundamentalGroupoidFunctor.piTopToPiCone._proof_1 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Product | ∀ {I : Type u_1} (X : I → TopCat) (j : CategoryTheory.Discrete I),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.pi' (FundamentalGroupoidFunctor.proj X))
((CategoryTheory.Grpd.piLimitFan fun i => FundamentalGroupoid.fundamentalGroupoidFunctor.obj (X i)).π.app j) =
(CategoryTheory.Limits.Fan.mk ... | false |
AddSubgroup.map_subtype_le_map_subtype._simp_1 | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : AddGroup G] {G' : AddSubgroup G} {H K : AddSubgroup ↥G'},
(AddSubgroup.map G'.subtype H ≤ AddSubgroup.map G'.subtype K) = (H ≤ K) | false |
_private.Init.Data.Vector.Lex.0.Break.runK.match_1.splitter | Init.Data.Vector.Lex | {α : Type u_1} →
(motive : Option α → Sort u_2) → (x : Option α) → ((a : α) → motive (some a)) → (Unit → motive none) → motive x | true |
CategoryTheory.Enriched.Functor.whiskerRight_app_apply | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(K L M N : CategoryTheory.Functor C D)
(f : CategoryTheory.MonoidalCategoryStruct.tensorObj (K.functorHom L) (L.functorHom M) ⟶ K.functorHom M) {X : C}
(a :
(CategoryTheory.MonoidalCategoryStru... | true |
Matrix.SpecialLinearGroup.mem_center_iff | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R]
{A : Matrix.SpecialLinearGroup n R},
A ∈ Subgroup.center (Matrix.SpecialLinearGroup n R) ↔ ∃ r, r ^ Fintype.card n = 1 ∧ (Matrix.scalar n) r = ↑A | true |
groupCohomology.isCoboundary₁_of_mem_coboundaries₁ | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G A : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : AddCommGroup A] [inst_3 : Module k A]
[inst_4 : DistribMulAction G A] [inst_5 : SMulCommClass G k A],
∀ f ∈ groupCohomology.coboundaries₁ (Rep.ofDistribMulAction k G A), groupCohomology.IsCoboundary₁ f | true |
Lean.Elab.Tactic.Omega.Problem.explanation?._default | Lean.Elab.Tactic.Omega.Core | Thunk String | false |
_private.Lean.Elab.Tactic.Grind.Sym.0.Lean.Elab.Tactic.Grind.evalSymInternalizeAll | Lean.Elab.Tactic.Grind.Sym | Lean.Elab.Tactic.Grind.GrindTactic | true |
hasDerivAt_add_const_iff | Mathlib.Analysis.Calculus.Deriv.Add | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} (c : F),
HasDerivAt (fun x => f x + c) f' x ↔ HasDerivAt f f' x | true |
CategoryTheory.Grp.whiskerLeft_hom_hom | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {G H : CategoryTheory.Grp C} (f : G ⟶ H) (I : CategoryTheory.Grp C),
(CategoryTheory.MonoidalCategoryStruct.whiskerRight f I).hom.hom =
CategoryTheory.Mon... | true |
Std.Http.Method.ctorElimType | Std.Internal.Http.Data.Method | {motive : Std.Http.Method → Sort u} → ℕ → Sort (max 1 u) | false |
Frm.hom_comp | Mathlib.Order.Category.Frm | ∀ {X Y Z : Frm} (f : X ⟶ Y) (g : Y ⟶ Z),
Frm.Hom.hom (CategoryTheory.CategoryStruct.comp f g) = (Frm.Hom.hom g).comp (Frm.Hom.hom f) | true |
Std.TreeSet.Raw.Equiv.max?_eq | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.max? = t₂.max? | true |
Filter.neBot_inf_comap_iff_map | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {F : Filter α} {G : Filter β},
(F ⊓ Filter.comap f G).NeBot ↔ (Filter.map f F ⊓ G).NeBot | true |
SubAddAction.ofFixingAddSubgroup_of_eq._proof_3 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ (M : Type u_1) {α : Type u_2} [inst : AddGroup M] [inst_1 : AddAction M α] {s t : Set α} (hst : s = t)
(x : ↥(fixingAddSubgroup M s)) (x_1 : ↥(SubAddAction.ofFixingAddSubgroup M s)),
(match x +ᵥ x_1 with
| ⟨x, hx⟩ => ⟨x, ⋯⟩) =
(AddEquiv.addSubgroupCongr ⋯) x +ᵥ
match x_1 with
| ⟨x, hx⟩ => ⟨x, ... | false |
Lattice.copy._proof_1 | Mathlib.Order.Copy | ∀ {α : Type u_1} (c : Lattice α) (le : α → α → Prop), le = LE.le → ∀ (a : α), le a a | false |
UpperSet.codisjoint_coe._simp_2 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α] {s t : UpperSet α}, Codisjoint ↑s ↑t = Disjoint s t | false |
Mathlib.Tactic.Ring.Common.RingCompare.eq | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{BaseType : Q(«$α») → Type} →
Mathlib.Tactic.Ring.Common.RingCompare BaseType → {x y : Q(«$α»)} → BaseType x → BaseType y → Bool | true |
RootPairing.Hom.recOn | Mathlib.LinearAlgebra.RootSystem.Hom | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_3} →
{N : Type u_4} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R N] →
{ι₂ : Type u_5} →
... | false |
Filter.le_add_iff._simp_1 | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Add α] {f g h : Filter α},
(h ≤ f + g) = ∀ ⦃s : Set α⦄, s ∈ f → ∀ ⦃t : Set α⦄, t ∈ g → s + t ∈ h | false |
RingQuot.definition._proof_4._@.Mathlib.Algebra.RingQuot.1987113737._hygCtx._hyg.2 | Mathlib.Algebra.RingQuot | ∀ {R : Type u_2} [inst : Semiring R] {T : Type u_1} [inst_1 : Semiring T] {r : R → R → Prop} (F : RingQuot r →+* T)
(x x_1 : R), r x x_1 → F ((RingQuot.mkRingHom r) x) = F ((RingQuot.mkRingHom r) x_1) | false |
BitVec.getLsbD_last | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x : BitVec w), x.getLsbD (w - 1) = decide (2 ^ (w - 1) ≤ x.toNat) | true |
Module.End.genEigenspace_zero | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {R : Type v} {M : Type w} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f : Module.End R M}
{μ : R}, (f.genEigenspace μ) 0 = ⊥ | true |
Sum.isLeft.match_1 | Init.Data.Sum.Basic | {α : Type u_1} →
{β : Type u_2} →
(motive : α ⊕ β → Sort u_3) →
(x : α ⊕ β) → ((val : α) → motive (Sum.inl val)) → ((val : β) → motive (Sum.inr val)) → motive x | false |
CategoryTheory.Bimon.toComon_map_hom | Mathlib.CategoryTheory.Monoidal.Bimon_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {X Y : CategoryTheory.Comon (CategoryTheory.Mon C)} (f : X ⟶ Y),
((CategoryTheory.Bimon.toComon C).map f).hom = f.hom.hom | true |
QuadraticMap.lift._simp_6 | Mathlib.LinearAlgebra.QuadraticForm.Radical | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup N]
[inst_3 : Module R M] [inst_4 : Module R N] (Q : QuadraticMap R M N) (m y : M),
QuadraticMap.polar (⇑Q) m y = (Q.polarBilin m) y | false |
NumberField.canonicalEmbedding.latticeBasis._proof_6 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
((Pi.basisFun ℂ (K →+* ℂ)).toMatrix fun i =>
(NumberField.canonicalEmbedding K) ((NumberField.integralBasis K) ((Fintype.equivOfCardEq ⋯) i))).det ≠
0 →
LinearIndependent ℂ fun i =>
(NumberField.canonicalEmbedding K) ((NumberField.i... | false |
CategoryTheory.MonoidalCategory.leftUnitorNatIso_inv_app | Mathlib.CategoryTheory.Monoidal.Category | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C),
(CategoryTheory.MonoidalCategory.leftUnitorNatIso C).inv.app X =
(CategoryTheory.MonoidalCategoryStruct.leftUnitor X).inv | true |
Std.Tactic.BVDecide.Gate.eval.eq_3 | Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic | Std.Tactic.BVDecide.Gate.beq.eval = fun x1 x2 => x1 == x2 | true |
BialgHom.copy._proof_3 | Mathlib.RingTheory.Bialgebra.Hom | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : CoalgebraStruct R A] [inst_6 : CoalgebraStruct R B]
(f : A →ₐc[R] B) (f' : A → B) (h : f' = ⇑f), ((↑f).copy f' h).toFun 1 = 1 | false |
BitVec.xor_right_inj | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w} (z : BitVec w), z ^^^ x = z ^^^ y ↔ x = y | true |
Std.Http.Method.mkredirectref.sizeOf_spec | Std.Internal.Http.Data.Method | sizeOf Std.Http.Method.mkredirectref = 1 | true |
_private.Mathlib.MeasureTheory.VectorMeasure.BoundedVariation.0.BoundedVariationOn.vectorMeasure_Iio._proof_1_2 | Mathlib.MeasureTheory.VectorMeasure.BoundedVariation | ∀ {E : Type u_1} [inst_7 : NormedAddCommGroup E], Nonempty E | false |
Lean.Lsp.ResolvableCompletionList.items | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.ResolvableCompletionList → Array Lean.Lsp.ResolvableCompletionItem | true |
Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVLogical.mk.injEq | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect | ∀ (bvExpr : Std.Tactic.BVDecide.BVLogicalExpr) (originalExpr : Lean.Expr)
(evalsAtAtoms' : Lean.Elab.Tactic.BVDecide.Frontend.M (Option Lean.Expr)) (expr : Lean.Expr)
(bvExpr_1 : Std.Tactic.BVDecide.BVLogicalExpr) (originalExpr_1 : Lean.Expr)
(evalsAtAtoms'_1 : Lean.Elab.Tactic.BVDecide.Frontend.M (Option Lean.Ex... | true |
Multiset.cons._proof_1 | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} (a : α) (x x_1 : List α),
(List.isSetoid α) x x_1 → Quot.mk (⇑(List.isSetoid α)) (a :: x) = Quot.mk (⇑(List.isSetoid α)) (a :: x_1) | false |
_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.Impl.pruneLE.match_1.splitter | Std.Data.DTreeMap.Internal.Zipper | (motive : Ordering → Sort u_1) →
(x : Ordering) → (Unit → motive Ordering.lt) → (Unit → motive Ordering.eq) → (Unit → motive Ordering.gt) → motive x | true |
StarSubalgebra.subtype_comp_inclusion | 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₁ S₂ : StarSubalgebra R A} (h : S₁ ≤ S₂),
S₂.subtype.comp (StarSubalgebra.inclusion h) = S₁.subtype | true |
IsStrictlyPositive.commute_iff | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Instances | ∀ {A : Type u_1} [inst : Ring A] [inst_1 : PartialOrder A] [inst_2 : StarRing A] [StarOrderedRing A]
[inst_4 : TopologicalSpace A] [inst_5 : Algebra ℝ A] [ContinuousFunctionalCalculus ℝ A IsSelfAdjoint]
[NonnegSpectrumClass ℝ A] {a b : A},
IsStrictlyPositive a → IsStrictlyPositive b → (Commute a b ↔ IsStrictlyPos... | true |
Nat.sub_mul_mod | Init.Data.Nat.Lemmas | ∀ {x k n : ℕ}, n * k ≤ x → (x - n * k) % n = x % n | true |
_private.Init.Data.Array.Basic.0.List.toArrayAux.match_1.eq_2 | Init.Data.Array.Basic | ∀ {α : Type u_1} (motive : List α → Array α → Sort u_2) (a : α) (as : List α) (xs : Array α)
(h_1 : (xs : Array α) → motive [] xs) (h_2 : (a : α) → (as : List α) → (xs : Array α) → motive (a :: as) xs),
(match a :: as, xs with
| [], xs => h_1 xs
| a :: as, xs => h_2 a as xs) =
h_2 a as xs | true |
CategoryTheory.Limits.Bicones.functoriality_obj_ι | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type w} {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {D : Type uD} [inst_2 : CategoryTheory.Category.{uD', uD} D]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] (F : J → C) (G : CategoryTheory.Functor C D)
[inst_4 : G.PreservesZeroMorph... | true |
_private.Lean.Expr.0.Lean.natSubFn | Lean.Expr | Lean.Expr | true |
OreLocalization.nonempty_oreSet_iff_of_noZeroDivisors | Mathlib.RingTheory.OreLocalization.OreSet | ∀ {R : Type u_1} [inst : Ring R] [NoZeroDivisors R] {S : Submonoid R},
Nonempty (OreLocalization.OreSet S) ↔ ∀ (r : R) (s : ↥S), ∃ r' s', ↑s' * r = r' * ↑s | true |
Std.Time.TimeZone.TZif.Header.mk.injEq | Std.Time.Zoned.Database.TzIf | ∀ (version : UInt8) (isutcnt isstdcnt leapcnt timecnt typecnt charcnt : UInt32) (version_1 : UInt8)
(isutcnt_1 isstdcnt_1 leapcnt_1 timecnt_1 typecnt_1 charcnt_1 : UInt32),
({ version := version, isutcnt := isutcnt, isstdcnt := isstdcnt, leapcnt := leapcnt, timecnt := timecnt,
typecnt := typecnt, charcnt :=... | true |
HasFPowerSeriesWithinAt.analyticWithinAt | Mathlib.Analysis.Analytic.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{p : FormalMultilinearSeries 𝕜 E F} {s : Set E} {x : E}, HasFPowerSeriesWithinAt f p s x → Analytic... | true |
_private.Lean.Meta.Tactic.Grind.MatchCond.0.Lean.Meta.Grind.collectMatchCondLhssAndAbstract.go.match_3 | Lean.Meta.Tactic.Grind.MatchCond | (motive : Lean.Expr × Option Lean.Expr → Sort u_1) →
(x : Lean.Expr × Option Lean.Expr) → ((lhs : Lean.Expr) → (α? : Option Lean.Expr) → motive (lhs, α?)) → motive x | false |
Int32.mul | Init.Data.SInt.Basic | Int32 → Int32 → Int32 | true |
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.testBit_log2._proof_1_2 | Init.Data.Nat.Bitwise.Lemmas | ∀ {n : ℕ}, (n.log2 = n.log2 ↔ 2 ^ n.log2 ≤ n ∧ n < 2 ^ (n.log2 + 1)) → ¬n < 2 ^ (n.log2 + 1) → False | false |
ContinuousLinearMap.sub | Mathlib.Topology.Algebra.Module.LinearMap | {R : Type u_1} →
[inst : Ring R] →
{R₂ : Type u_2} →
[inst_1 : Ring R₂] →
{M : Type u_4} →
[inst_2 : TopologicalSpace M] →
[inst_3 : AddCommGroup M] →
{M₂ : Type u_5} →
[inst_4 : TopologicalSpace M₂] →
[inst_5 : AddCommGroup M₂] →... | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.equiv_of_beq._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t t' : Std.DTreeMap.Internal.Impl α β}, t.Equiv t' = t.toListModel.Perm t'.toListModel | false |
Std.Do.SPred.Tactic.Exact.from_tautology | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {φ : Prop} {P T : Std.Do.SPred σs} [Std.Do.SPred.Tactic.PropAsSPredTautology φ T], φ → P ⊢ₛ T | true |
String.Slice.sliceTo._proof_1 | Init.Data.String.Basic | ∀ (s : String.Slice) (pos : s.Pos), s.startInclusive ≤ pos.str | false |
USize.land | Init.Data.UInt.Basic | USize → USize → USize | true |
Iff.iff | Mathlib.Logic.Basic | ∀ {p₁ p₂ q₁ q₂ : Prop}, (p₁ ↔ p₂) → (q₁ ↔ q₂) → ((p₁ ↔ q₁) ↔ (p₂ ↔ q₂)) | true |
CategoryTheory.NatTrans.commShiftPullback | Mathlib.CategoryTheory.Shift.Pullback | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u_2} {B : Type u_3} [inst_1 : AddMonoid A]
[inst_2 : AddMonoid B] (φ : A →+ B) [inst_3 : CategoryTheory.HasShift C B] {D : Type u_4}
[inst_4 : CategoryTheory.Category.{v_2, u_4} D] [inst_5 : CategoryTheory.HasShift D B]
{F : CategoryTheory.F... | true |
Matrix.instModuleForall._proof_2 | Mathlib.Data.Matrix.Action | ∀ {n : Type u_1} {R : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R] (v : n → R),
Matrix.mulVec 1 v = v | false |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic.0.CFC.inverse_rpow._proof_1_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : Ring A] (a : A), IsStrictlyPositive a → IsStrictlyPositive a | false |
CategoryTheory.ProjectiveResolution.Hom.hom_comp_π_assoc | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (P : CategoryTheory.ProjectiveResolution Z) {Z' : C}
(P' : CategoryTheory.ProjectiveResolution Z') {f : Z ⟶ Z'} (φ : P.Hom P' f) {Z_1 : ChainComplex C... | true |
CategoryTheory.Pseudofunctor.StrongTrans.Modification.rec | Mathlib.CategoryTheory.Bicategory.Modification.Pseudo | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.Pseudofunctor B C} →
{η θ : F ⟶ G} →
{motive : CategoryTheory.Pseudofunctor.StrongTrans.Modification η θ → Sort u} →
((app : (a : ... | false |
Nat.toArray_rio_add_add_eq_append | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (*...m + n).toArray = (*...m).toArray ++ (m...m + n).toArray | true |
_private.Init.Data.Array.Lemmas.0.Array.mem_iff_getElem.match_1_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {a : α} {xs : Array α} (motive : (∃ i, ∃ (h : i < xs.size), xs[i] = a) → Prop)
(x : ∃ i, ∃ (h : i < xs.size), xs[i] = a), (∀ (w : ℕ) (w_1 : w < xs.size) (e : xs[w] = a), motive ⋯) → motive x | false |
Std.Iter.length_eq_fold | Init.Data.Iterators.Lemmas.Consumers.Loop | ∀ {α β : Type w} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] [inst_2 : Std.IteratorLoop α Id Id]
[Std.LawfulIteratorLoop α Id Id] [inst_4 : Std.IteratorLoop α Id Id] [Std.LawfulIteratorLoop α Id Id]
{it : Std.Iter β}, it.length = Std.Iter.fold (fun acc x => acc + 1) 0 it | true |
AlgEquiv.restrictScalars_symm_apply | Mathlib.Algebra.Algebra.Tower | ∀ (R : Type u) {S : Type v} {A : Type w} {B : Type u₁} [inst : CommSemiring R] [inst_1 : CommSemiring S]
[inst_2 : Semiring A] [inst_3 : Semiring B] [inst_4 : Algebra R S] [inst_5 : Algebra S A] [inst_6 : Algebra S B]
[inst_7 : Algebra R A] [inst_8 : Algebra R B] [inst_9 : IsScalarTower R S A] [inst_10 : IsScalarTo... | true |
Mathlib.Meta.FunProp.LambdaTheoremArgs._sizeOf_inst | Mathlib.Tactic.FunProp.Theorems | SizeOf Mathlib.Meta.FunProp.LambdaTheoremArgs | false |
Stream'.append_right_injective | Mathlib.Data.Stream.Init | ∀ {α : Type u} (x : List α) (a b : Stream' α), x ++ₛ a = x ++ₛ b → a = b | true |
_private.Init.Data.List.ToArray.0.Array.takeWhile.eq_1 | Init.Data.List.ToArray | ∀ {α : Type u} (p : α → Bool) (as : Array α), Array.takeWhile p as = Array.takeWhile.go✝ p as 0 #[] | true |
Bundle.RiemannianMetric.noConfusionType | Mathlib.Topology.VectorBundle.Riemannian | Sort u →
{B : Type u_4} →
{E : B → Type u_6} →
[inst : (b : B) → TopologicalSpace (E b)] →
[inst_1 : (b : B) → AddCommGroup (E b)] →
[inst_2 : (b : B) → Module ℝ (E b)] →
Bundle.RiemannianMetric E →
{B' : Type u_4} →
{E' : B' → Type u_6} →
... | false |
_private.Mathlib.GroupTheory.DoubleCoset.0.DoubleCoset.iUnion_finset_leftRel_eq_univ_of_leftRel._simp_1_7 | Mathlib.GroupTheory.DoubleCoset | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_148 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α),
2 ≤ List.count w_1 [g a, g (g a)] →
List.idxOfNth w [] [].length < (List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length | false |
TopologicalSpace.OpenNhdsOf.toOpens_injective | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} [inst : TopologicalSpace α] {x : α}, Function.Injective TopologicalSpace.OpenNhdsOf.toOpens | true |
ContinuousLinearMap.norm_iteratedFDerivWithin_le_of_bilinear_of_le_one | Mathlib.Analysis.Calculus.ContDiff.Bounds | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {D : Type uD} [inst_1 : NormedAddCommGroup D]
[inst_2 : NormedSpace 𝕜 D] {E : Type uE} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E] {F : Type uF}
[inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace 𝕜 F] {G : Type uG} [inst_7 : NormedAddCommGro... | true |
SimpleGraph.Walk.cons.noConfusion | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | {V : Type u} →
{G : SimpleGraph V} →
{P : Sort u_1} →
{u v w : V} →
{h : G.Adj u v} →
{p : G.Walk v w} →
{u' v' w' : V} →
{h' : G.Adj u' v'} →
{p' : G.Walk v' w'} →
u = u' →
w = w' →
Simpl... | false |
MeasureTheory.ae_eq_zero_restrict_of_forall_setIntegral_eq_zero_real | Mathlib.MeasureTheory.Function.AEEqOfIntegral | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℝ},
(∀ (s : Set α), MeasurableSet s → μ s < ⊤ → MeasureTheory.IntegrableOn f s μ) →
(∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ∫ (x : α) in s, f x ∂μ = 0) →
∀ {t : Set α}, MeasurableSet t → μ t ≠ ⊤ → f =ᵐ[μ.restrict t] 0 | true |
_private.Mathlib.Data.PNat.Find.0.PNat.decidablePredExistsNat._simp_1 | Mathlib.Data.PNat.Find | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | false |
CategoryTheory.ShortComplex.abToCycles | Mathlib.Algebra.Homology.ShortComplex.Ab | (S : CategoryTheory.ShortComplex Ab) → ↑S.X₁ →+ ↥(AddCommGrpCat.Hom.hom S.g).ker | true |
TwoSidedIdeal.mem_bot._simp_1 | Mathlib.RingTheory.TwoSidedIdeal.Lattice | ∀ (R : Type u_1) [inst : NonUnitalNonAssocRing R] {x : R}, (x ∈ ⊥) = (x = 0) | false |
ordinaryHypergeometricSeries_eq_zero_of_neg_nat | Mathlib.Analysis.SpecialFunctions.OrdinaryHypergeometric | ∀ {𝕂 : Type u_1} {𝔸 : Type u_2} [inst : Field 𝕂] [inst_1 : Ring 𝔸] [inst_2 : Algebra 𝕂 𝔸] [inst_3 : TopologicalSpace 𝔸]
[inst_4 : IsTopologicalRing 𝔸] (a b c : 𝕂) {n k : ℕ},
↑k = -a ∨ ↑k = -b ∨ ↑k = -c → k < n → ordinaryHypergeometricSeries 𝔸 a b c n = 0 | true |
TopologicalSpace.Opens.frameMinimalAxioms | Mathlib.Topology.Sets.Opens | {α : Type u_2} → [inst : TopologicalSpace α] → Order.Frame.MinimalAxioms (TopologicalSpace.Opens α) | true |
AddSubmonoid.closure_induction₂ | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : AddZeroClass M] {s : Set M}
{motive : (x y : M) → x ∈ AddSubmonoid.closure s → y ∈ AddSubmonoid.closure s → Prop},
(∀ (x y : M) (hx : x ∈ s) (hy : y ∈ s), motive x y ⋯ ⋯) →
(∀ (x : M) (hx : x ∈ AddSubmonoid.closure s), motive 0 x ⋯ hx) →
(∀ (x : M) (hx : x ∈ AddSubmonoid.closure s... | true |
Std.Iterators.Types.ListIterator.instIterator.eq_1 | Init.Data.Iterators.Producers.Monadic.List | ∀ {m : Type w → Type w'} {α : Type w} [inst : Pure m],
Std.Iterators.Types.ListIterator.instIterator =
{
IsPlausibleStep := fun it x =>
match x with
| Std.IterStep.yield it' out => it.internalState.list = out :: it'.internalState.list
| Std.IterStep.skip it => False
| Std.Ite... | true |
_private.Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable.0.summable_jacobiTheta₂'_term_iff._simp_1_4 | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] {a : ℤ}, |↑a| = ↑|a| | false |
RingEquiv.coe_toMulEquiv_symm | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_4} {S : Type u_5} [inst : Mul R] [inst_1 : Mul S] [inst_2 : Add R] [inst_3 : Add S] (e : R ≃+* S),
↑e.symm = (↑e).symm | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.