name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
OrderAddMonoidIso.instAddEquivClass | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Add α] [inst_3 : Add β],
AddEquivClass (α ≃+o β) α β | true |
Polynomial.Monic.isUnit_leadingCoeff_of_dvd | Mathlib.Algebra.Polynomial.Roots | ∀ {R : Type u} [inst : CommRing R] [IsDomain R] {a p : Polynomial R}, p.Monic → a ∣ p → IsUnit a.leadingCoeff | true |
«DistribMulActionHomIdLocal≺» | Mathlib.GroupTheory.GroupAction.Hom | Lean.TrailingParserDescr | true |
topToPreord_obj_coe | Mathlib.Topology.Specialization | ∀ (X : TopCat), ↑(topToPreord.obj X) = Specialization ↑X | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_182 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w_1 : α),
List.idxOfNth w_1 [g a, g (g a)] [].length + 1 ≤ (List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length →
List.idxOfNth w_1 [g a, g (g a)] [].length < (List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length | false |
Sequential.isoEquivHomeo | Mathlib.Topology.Category.Sequential | {X Y : Sequential} → (X ≅ Y) ≃ (↑X.toTop ≃ₜ ↑Y.toTop) | true |
instAddMonoidUniformOnFun._aux_4 | Mathlib.Topology.Algebra.UniformConvergence | {α : Type u_1} → {β : Type u_2} → {𝔖 : Set (Set α)} → [AddMonoid β] → ℕ → UniformOnFun α β 𝔖 → UniformOnFun α β 𝔖 | false |
Std.HashMap.Raw.getElem!_alter | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [inst_2 : EquivBEq α]
[LawfulHashable α] {k k' : α} [inst_4 : Inhabited β] {f : Option β → Option β},
m.WF → (m.alter k f)[k']! = if (k == k') = true then (f m[k]?).get! else m[k']! | true |
Set.ite | Mathlib.Order.BooleanAlgebra.Set | {α : Type u_1} → Set α → Set α → Set α → Set α | true |
CategoryTheory.DifferentialObject.shiftFunctorAdd | Mathlib.CategoryTheory.DifferentialObject | {S : Type u_1} →
[inst : AddCommGroupWithOne S] →
(C : Type u) →
[inst_1 : CategoryTheory.Category.{v, u} C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_3 : CategoryTheory.HasShift C S] →
(m n : S) →
CategoryTheory.DifferentialObject.shiftFunctor... | true |
Nat.Partrec.below.left | Mathlib.Computability.Partrec | ∀ {motive : (a : ℕ →. ℕ) → Nat.Partrec a → Prop}, Nat.Partrec.below Nat.Partrec.left | true |
MvFunctor.id_map' | Mathlib.Control.Functor.Multivariate | ∀ {n : ℕ} {α : TypeVec.{u} n} {F : TypeVec.{u} n → Type v} [inst : MvFunctor F] [LawfulMvFunctor F] (x : F α),
MvFunctor.map (fun _i a => a) x = x | true |
TopModuleCat.indiscrete._proof_2 | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | ∀ (R : Type u_1) [inst : Ring R] [inst_1 : TopologicalSpace R] (X : ModuleCat R), Continuous fun p => p.1 • p.2 | false |
Isometry.cospherical | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {E : Type u_3} {F : Type u_4} [inst : MetricSpace E] [inst_1 : MetricSpace F] {f : E → F},
Isometry f → ∀ {ps : Set E}, EuclideanGeometry.Cospherical ps → EuclideanGeometry.Cospherical (f '' ps) | true |
_private.Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension.0.ExistsContDiffBumpBase.instHasContDiffBumpOfFiniteDimensionalReal._simp_2 | Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | ∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True | false |
Subring.instCommRingSubtypeMemCenter._proof_4 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u_1} [inst : Ring R] (n : ℕ) (a : ↥(Subring.center R)),
Ring.zsmul (Int.negSucc n) a = -Ring.zsmul (↑n.succ) a | false |
Ordinal.iSup_eq_iSup | Mathlib.SetTheory.Ordinal.Family | ∀ {ι ι' : Type u} (r : ι → ι → Prop) (r' : ι' → ι' → Prop) [inst : IsWellOrder ι r] [inst_1 : IsWellOrder ι' r']
{o : Ordinal.{u}} (ho : Ordinal.type r = o) (ho' : Ordinal.type r' = o)
(f : (a : Ordinal.{u}) → a < o → Ordinal.{u_4}),
iSup (Ordinal.familyOfBFamily' r ho f) = iSup (Ordinal.familyOfBFamily' r' ho' f... | true |
_private.Mathlib.MeasureTheory.Constructions.BorelSpace.Real.0.Real.borel_eq_generateFrom_Iio_rat._simp_1_2 | Mathlib.MeasureTheory.Constructions.BorelSpace.Real | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α} {a : α}, (a ∈ upperBounds s) = ∀ x ∈ s, x ≤ a | false |
_private.Mathlib.GroupTheory.Coxeter.Basic.0.CoxeterSystem.getElem_alternatingWord_swapIndices._simp_1_2 | Mathlib.GroupTheory.Coxeter.Basic | ∀ {α : Sort u_1} {p : Prop} [inst : Decidable p] {x y : α}, ((if p then x else y) = y) = (p → x = y) | false |
_private.Mathlib.Algebra.BigOperators.Ring.Nat.0.Finset.even_sum_iff_even_card_odd._simp_1_1 | Mathlib.Algebra.BigOperators.Ring.Nat | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a) | false |
Array.max?_toList | Init.Data.Array.MinMax | ∀ {α : Type u_1} [inst : Max α] {xs : Array α}, xs.toList.max? = xs.max? | true |
CategoryTheory.InjectiveResolution.isLimitKernelFork._proof_6 | Mathlib.CategoryTheory.Preadditive.Injective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {Z : C},
((HomologicalComplex.single C (ComplexShape.up ℕ) 0).obj Z).HasHomology 0 | false |
SimpleGraph.Iso.connectedComponentEquiv_symm_apply | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} (φ : G ≃g G') (C : G'.ConnectedComponent),
φ.connectedComponentEquiv.symm C = SimpleGraph.ConnectedComponent.map (RelIso.toRelEmbedding φ.symm).toRelHom C | true |
Nat.Ico_filter_pow_dvd_eq | Mathlib.Data.Nat.Factorization.Basic | ∀ {n p b : ℕ}, Nat.Prime p → n ≠ 0 → n ≤ p ^ b → {i ∈ Finset.Ico 1 n | p ^ i ∣ n} = {i ∈ Finset.Icc 1 b | p ^ i ∣ n} | true |
_private.Mathlib.Order.ScottContinuity.0.ScottContinuousOn.snd._simp_1_1 | Mathlib.Order.ScottContinuity | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {s : Set (α × β)} {p : α × β},
IsLUB s p = (IsLUB (Prod.fst '' s) p.1 ∧ IsLUB (Prod.snd '' s) p.2) | false |
_private.Mathlib.Tactic.DefEqTransformations.0.Mathlib.Tactic.getProjectedExpr.match_1 | Mathlib.Tactic.DefEqTransformations | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((S : Lean.Name) → (i : ℕ) → (x : Lean.Expr) → motive (Lean.Expr.proj S i x)) →
((x : Lean.Expr) → motive x) → motive e | false |
_private.Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis.0.AlgebraicIndependent.matroid_isFlat_of_subsingleton._simp_1_3 | Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis | ∀ {α : Type u} (s : Set α), (s ⊆ Set.univ) = True | false |
Lean.Meta.Grind.Arith.Linear.RingDiseqCnstrProof.brecOn.go | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {motive_1 : Lean.Meta.Grind.Arith.Linear.RingDiseqCnstr → Sort u} →
{motive_2 : Lean.Meta.Grind.Arith.Linear.RingDiseqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Linear.RingDiseqCnstrProof) →
((t : Lean.Meta.Grind.Arith.Linear.RingDiseqCnstr) → t.below → motive_1 t) →
((t : Lean.Meta.Grind.Ari... | true |
AlgebraicGeometry.Scheme.Cover.ColimitGluingData.pullbackGluedIso_inv_fst | Mathlib.AlgebraicGeometry.ColimitsOver | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [inst : P.IsStableUnderBaseChange]
[inst_1 : P.IsMultiplicative] {S : AlgebraicGeometry.Scheme} {J : Type u_1}
[inst_2 : CategoryTheory.Category.{v_1, u_1} J] {D : CategoryTheory.Functor J (P.Over ⊤ S)} {𝒰 : S.OpenCover}
[inst_3 : CategoryTheory.Ca... | true |
BitVec.getElem_shiftLeftZeroExtend | Init.Data.BitVec.Lemmas | ∀ {m i : ℕ} {x : BitVec m} {n : ℕ} (h : i < m + n),
(x.shiftLeftZeroExtend n)[i] = if h' : i < n then false else x[i - n] | true |
starLinearEquiv_tensor | Mathlib.Algebra.Star.TensorProduct | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : AddCommMonoid A]
[inst_3 : StarAddMonoid A] [inst_4 : Module R A] [inst_5 : StarModule R A] [inst_6 : AddCommMonoid B]
[inst_7 : StarAddMonoid B] [inst_8 : Module R B] [inst_9 : StarModule R B],
starLinearEquiv ... | true |
RCLike.one_im | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], RCLike.im 1 = 0 | true |
_private.Mathlib.RingTheory.Etale.StandardEtale.0.StandardEtalePair.existsUnique_hasMap_of_hasMap_quotient_of_sq_eq_bot._proof_1_4 | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_2} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : StandardEtalePair R) (x ε b : S),
(Polynomial.aeval x) (Polynomial.derivative P.f) * b = 1 + ε →
(Polynomial.aeval x) P.f * ε = 0 →
(Polynomial.aeval x) P.f + (Polynomial.aeval x) (Polynomial.derivative P... | false |
IsAffineMonoid.mk | Mathlib.Algebra.AffineMonoid.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] [toIsCancelMul : IsCancelMul M] [toFG : Monoid.FG M]
[toIsMulTorsionFree : IsMulTorsionFree M], IsAffineMonoid M | true |
Turing.TM2.Stmt.peek.sizeOf_spec | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} [inst : SizeOf K] [inst_1 : (a : K) → SizeOf (Γ a)]
[inst_2 : SizeOf Λ] [inst_3 : SizeOf σ] (k : K) (a : σ → Option (Γ k) → σ) (a_1 : Turing.TM2.Stmt Γ Λ σ),
sizeOf (Turing.TM2.Stmt.peek k a a_1) = 1 + sizeOf k + sizeOf a_1 | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Util.0.Int.Linear.Poly.pp.go._sunfold | Lean.Meta.Tactic.Grind.Arith.Cutsat.Util | Lean.MessageData → Int.Linear.Poly → Lean.Meta.Grind.GoalM Lean.MessageData | false |
WithLp.coe_symm_addEquiv | Mathlib.Analysis.Normed.Lp.WithLp | ∀ (p : ENNReal) (V : Type u_4) [inst : AddCommGroup V], ⇑(WithLp.addEquiv p V).symm = WithLp.toLp p | true |
NormedAddGroupHom.mem_range_self._simp_1 | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_3} {V₂ : Type u_4} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
(f : NormedAddGroupHom V₁ V₂) (v : V₁), (f v ∈ f.range) = True | false |
Lean.ModuleData.noConfusion | Lean.Environment | {P : Sort u} → {t t' : Lean.ModuleData} → t = t' → Lean.ModuleData.noConfusionType P t t' | false |
CategoryTheory.Triangulated.TStructure.isIso_truncGE_map_truncGEπ_app | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryTheory.... | true |
_private.Mathlib.MeasureTheory.Integral.FinMeasAdditive.0.MeasureTheory.«_aux_Mathlib_MeasureTheory_Integral_FinMeasAdditive___macroRules__private_Mathlib_MeasureTheory_Integral_FinMeasAdditive_0_MeasureTheory_term_→ₛ__1» | Mathlib.MeasureTheory.Integral.FinMeasAdditive | Lean.Macro | false |
NormedAddCommGroup.toCompl._proof_3 | Mathlib.Analysis.Normed.Group.HomCompletion | ∀ {G : Type u_1} [inst : SeminormedAddCommGroup G], ∃ C, ∀ (v : G), ‖↑v‖ ≤ C * ‖v‖ | false |
_private.Mathlib.Analysis.Normed.Group.FunctionSeries.0.tendstoUniformlyOn_tsum_of_cofinite_eventually._simp_1_4 | Mathlib.Analysis.Normed.Group.FunctionSeries | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | false |
Lean.Export.Entry.expr.sizeOf_spec | Mathlib.Util.Export | ∀ (n : Lean.Expr), sizeOf (Lean.Export.Entry.expr n) = 1 + sizeOf n | true |
Std.Internal.IO.Async.TCP.Socket.Server.tryAccept | Std.Internal.Async.TCP | Std.Internal.IO.Async.TCP.Socket.Server → IO (Option Std.Internal.IO.Async.TCP.Socket.Client) | true |
List.SortedGE.reverse | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {l : List α} [inst : Preorder α], l.SortedGE → l.reverse.SortedLE | true |
CategoryTheory.CosimplicialObject.instCategoryAugmented._proof_8 | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C],
autoParam
(∀ {X Y : CategoryTheory.CosimplicialObject.Augmented C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y) = f)
CategoryTheory.Category.comp_id._autoParam | false |
Lean.Parser.Term.doLetArrow._regBuiltin.Lean.Parser.Term.doPatDecl.formatter_11 | Lean.Parser.Do | IO Unit | false |
_private.Mathlib.CategoryTheory.Monoidal.Action.Basic.0.CategoryTheory.MonoidalCategory.MonoidalRightAction.actionHomRight_comp._simp_1_2 | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ {C : Type u_1} {D : Type u_2} {inst : CategoryTheory.Category.{v_1, u_1} C}
{inst_1 : CategoryTheory.Category.{v_2, u_2} D} {inst_2 : CategoryTheory.MonoidalCategory C}
[self : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] {c c' c'' : C} {d d' d'' : D} (f₁ : d ⟶ d')
(f₂ : d' ⟶ d'') (g₁ : c ⟶ c') (g₂ ... | false |
ContDiff.iterate_deriv | Mathlib.Analysis.Calculus.ContDiff.Deriv | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] (n : ℕ) {f : 𝕜 → F}, ContDiff 𝕜 (↑⊤) f → ContDiff 𝕜 (↑⊤) (deriv^[n] f) | true |
List.prev | Mathlib.Data.List.Cycle | {α : Type u_1} → [DecidableEq α] → (l : List α) → (x : α) → x ∈ l → α | true |
Std.Internal.IO.Process.ResourceUsageStats.blockInputOps | Std.Internal.Async.Process | Std.Internal.IO.Process.ResourceUsageStats → UInt64 | true |
Finset.inter_congr_left | Mathlib.Data.Finset.Lattice.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {s t u : Finset α}, s ∩ u ⊆ t → s ∩ t ⊆ u → s ∩ t = s ∩ u | true |
CommGroupWithZero.div._inherited_default | Mathlib.Algebra.GroupWithZero.Defs | {G₀ : Type u_2} →
(mul : G₀ → G₀ → G₀) →
(∀ (a b c : G₀), a * b * c = a * (b * c)) →
(one : G₀) →
(∀ (a : G₀), 1 * a = a) →
(∀ (a : G₀), a * 1 = a) →
(npow : ℕ → G₀ → G₀) →
(∀ (x : G₀), npow 0 x = 1) →
(∀ (n : ℕ) (x : G₀), npow (n + 1) x = npow n x... | false |
CategoryTheory.Abelian.factorThruImage_comp_coimageIsoImage'_inv | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.factorThruImage f)
(CategoryTheory.Abelian.coimageIsoImage' f).inv =
CategoryTheory.Limits.cokernel.π (CategoryTheory.Limits.kernel.ι ... | true |
Lean.BinderInfo.instImplicit.elim | Lean.Expr | {motive : Lean.BinderInfo → Sort u} →
(t : Lean.BinderInfo) → t.ctorIdx = 3 → motive Lean.BinderInfo.instImplicit → motive t | false |
instCommSemiringENat._proof_4 | Mathlib.Data.ENat.Basic | ∀ (a b c : ℕ∞), a * (b + c) = a * b + a * c | false |
CategoryTheory.Adjunction.CoreHomEquivUnitCounit.unit | Mathlib.CategoryTheory.Adjunction.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D C} →
CategoryTheory.Adjunction.CoreHomEquivUnitCounit F G → (CategoryTheory.Functor.id ... | true |
MeasurableSpace.rec | Mathlib.MeasureTheory.MeasurableSpace.Defs | {α : Type u_7} →
{motive : MeasurableSpace α → Sort u} →
((MeasurableSet' : Set α → Prop) →
(measurableSet_empty : MeasurableSet' ∅) →
(measurableSet_compl : ∀ (s : Set α), MeasurableSet' s → MeasurableSet' sᶜ) →
(measurableSet_iUnion : ∀ (f : ℕ → Set α), (∀ (i : ℕ), MeasurableSet' (... | false |
CategoryTheory.Mon.equivLaxMonoidalFunctorPUnit_counitIso_hom_app_hom | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(X : CategoryTheory.Mon C),
(CategoryTheory.Mon.equivLaxMonoidalFunctorPUnit.counitIso.hom.app X).hom = CategoryTheory.CategoryStruct.id X.X | true |
AlgebraicGeometry.Spec.topObj_forget | Mathlib.AlgebraicGeometry.Spec | ∀ {R : CommRingCat}, CategoryTheory.ToType (AlgebraicGeometry.Spec.topObj R) = PrimeSpectrum ↑R | true |
Lean.Meta.Grind.Goal.introN | Lean.Meta.Sym.Grind | Lean.Meta.Grind.Goal → ℕ → Lean.Meta.Sym.SymM Lean.Meta.Grind.IntrosResult | true |
Algebra.commute_algebraMap_left | Mathlib.Algebra.Algebra.Defs | ∀ {R : Type u} {A : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (r : R) (x : A),
Commute ((algebraMap R A) r) x | true |
_private.Mathlib.Order.Monotone.MonovaryOrder.0.antivaryOn_iff_exists_monotoneOn_antitoneOn._simp_1_1 | Mathlib.Order.Monotone.MonovaryOrder | ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : ι → α} {g : ι → β}
{s : Set ι}, AntivaryOn f g s = MonovaryOn f (⇑OrderDual.toDual ∘ g) s | false |
Int64.xor_zero | Init.Data.SInt.Bitwise | ∀ {a : Int64}, a ^^^ 0 = a | true |
Lean.Elab.DerivingClassView.recOn | Lean.Elab.Deriving.Basic | {motive : Lean.Elab.DerivingClassView → Sort u} →
(t : Lean.Elab.DerivingClassView) →
((ref : Lean.Syntax) →
(hasExpose : Bool) → (cls : Lean.Term) → motive { ref := ref, hasExpose := hasExpose, cls := cls }) →
motive t | false |
_private.Mathlib.LinearAlgebra.Dual.Defs.0.Submodule.mem_dualCoannihilator._simp_1_2 | Mathlib.LinearAlgebra.Dual.Defs | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
{x : M} {f : M →ₛₗ[σ₁₂] M₂} {p : Submodule R₂ M₂}, (x ∈ Submodule.comap f p) = (f x ∈ p) | false |
LinearEquiv.annihilator_eq | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_1} {M : Type u_2} {M' : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (e : M ≃ₗ[R] M'), Module.annihilator R M = Module.annihilator R M' | true |
instShiftLeftInt32 | Init.Data.SInt.Basic | ShiftLeft Int32 | true |
CategoryTheory.CartesianMonoidalCategory.toSymmetricCategory._proof_2 | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X Y : C),
CategoryTheory.CategoryStruct.comp (β_ X Y).hom (β_ Y X).hom =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tenso... | false |
PowerSeries.WithPiTopology.instUniformSpace | Mathlib.RingTheory.PowerSeries.PiTopology | (R : Type u_1) → [UniformSpace R] → UniformSpace (PowerSeries R) | true |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.isCycle_rotate._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u : V} (p : G.Walk u u),
p.IsCycle = (p.IsTrail ∧ p ≠ SimpleGraph.Walk.nil ∧ p.support.tail.Nodup) | false |
instCommRingCorner._proof_7 | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} (e : R) [inst : NonUnitalCommRing R] (a : ↥(NonUnitalRing.corner e)), a * 0 = 0 | false |
Lean.Meta.Grind.Result.noConfusion | Lean.Meta.Tactic.Grind.Main | {P : Sort u} → {t t' : Lean.Meta.Grind.Result} → t = t' → Lean.Meta.Grind.Result.noConfusionType P t t' | false |
Subring.closure_mono | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} [inst : NonAssocRing R] ⦃s t : Set R⦄, s ⊆ t → Subring.closure s ≤ Subring.closure t | true |
List.append_sublist_of_sublist_left | Init.Data.List.Nat.Sublist | ∀ {α : Type u_1} {xs ys zs : List α}, zs.Sublist xs → ((xs ++ ys).Sublist zs ↔ ys = [] ∧ xs = zs) | true |
Class.«term⋃₀_» | Mathlib.SetTheory.ZFC.Class | Lean.ParserDescr | true |
WithBot.coe_inf | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : SemilatticeInf α] (a b : α), ↑(a ⊓ b) = ↑a ⊓ ↑b | true |
CategoryTheory.Limits.colimCompFlipIsoWhiskerColim | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type u₁} →
[inst_1 : CategoryTheory.Category.{v₁, u₁} J] →
{K : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} K] →
[inst_3 : CategoryTheory.Limits.HasColimitsOfShape J C] →
(CategoryTheory.fli... | true |
Turing.TM2to1.tr.eq_2 | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} [inst : DecidableEq K] (M : Λ → Turing.TM2.Stmt Γ Λ σ)
(k : K) (s : Turing.TM2to1.StAct K Γ σ k) (q : Turing.TM2.Stmt Γ Λ σ),
Turing.TM2to1.tr M (Turing.TM2to1.Λ'.go k s q) =
Turing.TM1.Stmt.branch (fun a x => (a.2 k).isNone)
(Turing.TM2to1... | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal.0.Polynomial.Chebyshev.negOnePow_mul_iterateDerivativeC_pos._proof_1_5 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal | ∀ {n k i : ℕ}, 0 < k → k ≤ n → (Finset.Icc 1 (n - k + 1)).erase i ⊆ (Finset.range (n + 1)).erase i | false |
CategoryTheory.Limits.coyonedaOpColimitIsoLimitCoyoneda'_inv_comp_π_assoc | Mathlib.CategoryTheory.Limits.IndYoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] {I : Type v₁} [inst_1 : CategoryTheory.Category.{v₂, v₁} I]
(F : CategoryTheory.Functor Iᵒᵖ C) [inst_2 : CategoryTheory.Limits.HasColimit F] (i : I)
{Z : CategoryTheory.Functor C (Type u₂)} (h : CategoryTheory.coyoneda.obj (Opposite.op (F.obj (Opposite.op ... | true |
ContinuousMap.yonedaPresheaf'_map | Mathlib.Topology.Category.TopCat.Yoneda | ∀ (Y : Type w') [inst : TopologicalSpace Y] {X Y_1 : TopCatᵒᵖ} (f : X ⟶ Y_1) (g : C(↑(Opposite.unop X), Y)),
(ContinuousMap.yonedaPresheaf' Y).map f g = g.comp (CategoryTheory.ConcreteCategory.hom f.unop) | true |
LinearMap.BilinForm.comp_symmCompOfNondegenerate_apply | Mathlib.LinearAlgebra.BilinearForm.Properties | ∀ {V : Type u_5} {K : Type u_6} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
[inst_3 : FiniteDimensional K V] (B₁ : LinearMap.BilinForm K V) {B₂ : LinearMap.BilinForm K V} (b₂ : B₂.Nondegenerate)
(v : V), B₂ ((B₁.symmCompOfNondegenerate B₂ b₂) v) = B₁ v | true |
Complex.wedgeIntegral.eq_1 | Mathlib.Analysis.Complex.HasPrimitives | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] (z w : ℂ) (f : ℂ → E),
z.wedgeIntegral w f =
(∫ (x : ℝ) in z.re..w.re, f (↑x + ↑z.im * Complex.I)) +
Complex.I • ∫ (y : ℝ) in z.im..w.im, f (↑w.re + ↑y * Complex.I) | true |
Lean.Parser.Category.rawStx | Init.Notation | Lean.Parser.Category | true |
CategoryTheory.Limits.π_reflexiveCoequalizerIsoCoequalizer_inv | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(F : CategoryTheory.Functor CategoryTheory.Limits.WalkingReflexivePair C)
[inst_1 :
CategoryTheory.Limits.HasCoequalizer (F.map CategoryTheory.Limits.WalkingReflexivePair.Hom.left)
(F.map CategoryTheory.Limits.WalkingReflexivePair.Hom.right)],
Cat... | true |
Std.DTreeMap.contains_of_contains_erase | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k a : α},
(t.erase k).contains a = true → t.contains a = true | true |
List.rotate_one_eq_self_iff_eq_replicate | Mathlib.Data.List.Rotate | ∀ {α : Type u} [Nonempty α] {l : List α}, l.rotate 1 = l ↔ ∃ a, l = List.replicate l.length a | true |
_private.Mathlib.Algebra.Module.Equiv.Basic.0.LinearEquiv.ofSubsingleton_self._simp_1_1 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {α : Sort u_1} [Subsingleton α] (x y : α), (x = y) = True | false |
_private.Mathlib.Algebra.Algebra.Operations.0.Submodule.map_op_mul._simp_1_1 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective σ₁₂] {f : M →ₛₗ[σ₁₂] M₂} {p : Submodule R M} {q : Submodule R₂ ... | false |
IsPartialOrder.toAntisymm | Mathlib.Order.Defs.Unbundled | ∀ {α : Sort u_1} {r : α → α → Prop} [self : IsPartialOrder α r], Std.Antisymm r | true |
Complex.tendsto_arg_nhdsWithin_im_nonneg_of_re_neg_of_im_zero | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ {z : ℂ}, z.re < 0 → z.im = 0 → Filter.Tendsto Complex.arg (nhdsWithin z {z | 0 ≤ z.im}) (nhds Real.pi) | true |
SimpleGraph.IsTree.casesOn | Mathlib.Combinatorics.SimpleGraph.Acyclic | {V : Type u_1} →
{G : SimpleGraph V} →
{motive : G.IsTree → Sort u} →
(t : G.IsTree) → ((connected : G.Connected) → (isAcyclic : G.IsAcyclic) → motive ⋯) → motive t | false |
DividedPowers.IsSubDPIdeal.mk._flat_ctor | Mathlib.RingTheory.DividedPowers.SubDPIdeal | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} {hI : DividedPowers I} {J : Ideal A},
J ≤ I → (∀ (n : ℕ), n ≠ 0 → ∀ {j : A}, j ∈ J → hI.dpow n j ∈ J) → hI.IsSubDPIdeal J | false |
Metric.Snowflaking.toSnowflaking.sizeOf_spec | Mathlib.Topology.MetricSpace.Snowflaking | ∀ {X : Type u_1} {α : ℝ} {hα₀ : 0 < α} {hα₁ : α ≤ 1} [inst : SizeOf X] (x : X),
sizeOf (Metric.Snowflaking.toSnowflaking x) = 1 + sizeOf x | true |
Std.DHashMap.getKeyD_eq_fallback_of_contains_eq_false | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [EquivBEq α] [LawfulHashable α]
{a fallback : α}, m.contains a = false → m.getKeyD a fallback = fallback | true |
Subalgebra.coe_val | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (S : Subalgebra R A),
⇑S.val = Subtype.val | true |
Aesop.GlobalRuleSet.ctorIdx | Aesop.RuleSet | Aesop.GlobalRuleSet → ℕ | false |
ForIn.mk | Init.Core | {m : Type u₁ → Type u₂} →
{ρ : Type u} → {α : outParam (Type v)} → ({β : Type u₁} → ρ → β → (α → β → m (ForInStep β)) → m β) → ForIn m ρ α | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.