name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
HomologicalComplex.restriction.congr_simp | Mathlib.Algebra.Homology.Embedding.TruncLEHomology | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K K_1 : HomologicalComplex C c'),
K = K_1 → ∀ (e e_1 : c.Embedding c') (e_e : e = e_1) [inst_2 : e.IsRelIff], K.restriction... | true |
Aesop.CasesTarget.ctorElimType | Aesop.RuleTac.Basic | {motive : Aesop.CasesTarget → Sort u} → ℕ → Sort (max 1 u) | false |
UInt32.reduceLE._regBuiltin.UInt32.reduceLE.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.2998934274._hygCtx._hyg.169 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | false |
IsSMulRegular.mul | Mathlib.Algebra.Regular.SMul | ∀ {R : Type u_1} {M : Type u_3} {a b : R} [inst : SMul R M] [inst_1 : Mul R] [IsScalarTower R R M],
IsSMulRegular M a → IsSMulRegular M b → IsSMulRegular M (a * b) | true |
Lean.Meta.Sym.Simp.simpForall' | Lean.Meta.Sym.Simp.Forall | Lean.Meta.Sym.Simp.Simproc → Lean.Meta.Sym.Simp.Simproc → Lean.Expr → Lean.Meta.Sym.Simp.SimpM Lean.Meta.Sym.Simp.Result | true |
IsIsometricSMul.mk._flat_ctor | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {M : Type u} {X : Type w} [inst : PseudoEMetricSpace X] [inst_1 : SMul M X],
(∀ (c : M), Isometry fun x => c • x) → IsIsometricSMul M X | false |
ProbabilityTheory.HasGaussianLaw.charFunDual_map_eq | Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} [inst : NormedAddCommGroup E]
[inst_1 : MeasurableSpace E] [BorelSpace E] {X : Ω → E} [inst_3 : NormedSpace ℝ E] (L : StrongDual ℝ E),
ProbabilityTheory.HasGaussianLaw X P →
MeasureTheory.charFunDual (MeasureTheory.Measure.ma... | true |
_private.Init.Data.String.Lemmas.Pattern.String.Basic.0.String.Slice.Pattern.Model.ForwardSliceSearcher.isLongestMatchAt_iff_splits._simp_1_1 | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {t : String} {s : String.Slice} {pos₁ pos₂ : s.Pos},
(∃ (h : pos₁ ≤ pos₂), (s.slice pos₁ pos₂ h).copy = t) = ∃ t₁ t₂, pos₁.Splits t₁ (t ++ t₂) ∧ pos₂.Splits (t₁ ++ t) t₂ | false |
MultilinearMap.mkContinuous_norm_le | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} {ι : Type v} {E : ι → Type wE} {G : Type wG} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι] (f : MultilinearMap 𝕜 E G)
{C : ℝ}, 0 ≤... | true |
_private.Lean.Elab.Tactic.BuiltinTactic.0.Lean.Elab.Tactic.evalReplace.match_1 | Lean.Elab.Tactic.BuiltinTactic | (motive : Option Lean.LocalDecl → Sort u_1) →
(x : Option Lean.LocalDecl) →
((ldecl : Lean.LocalDecl) → motive (some ldecl)) → ((x : Option Lean.LocalDecl) → motive x) → motive x | false |
CategoryTheory.ComposableArrows.sc'._auto_1 | Mathlib.Algebra.Homology.ExactSequence | Lean.Syntax | false |
QuadraticModuleCat.instMonoidalCategory | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat.Monoidal | {R : Type u} → [inst : CommRing R] → [Invertible 2] → CategoryTheory.MonoidalCategory (QuadraticModuleCat R) | true |
Subgroup.mem_goursatSnd | Mathlib.GroupTheory.Goursat | ∀ {G : Type u_1} {H : Type u_2} [inst : Group G] [inst_1 : Group H] {I : Subgroup (G × H)} {h : H},
h ∈ I.goursatSnd ↔ (1, h) ∈ I | true |
groupCohomology.H1IsoOfIsTrivial.congr_simp | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G) [inst_2 : A.IsTrivial],
groupCohomology.H1IsoOfIsTrivial A = groupCohomology.H1IsoOfIsTrivial A | true |
Std.DHashMap.Raw.getKeyD_insertIfNew | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
m.WF →
∀ {k a fallback : α} {v : β k},
(m.insertIfNew k v).getKeyD a fallback = if (k == a) = true ∧ k ∉ m then k else m.getKeyD a fallback | true |
AddMonoidAlgebra.singleZeroAlgHom.eq_1 | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_1} {A : Type u_4} {M : Type u_7} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : AddMonoid M],
AddMonoidAlgebra.singleZeroAlgHom = { toRingHom := AddMonoidAlgebra.singleZeroRingHom, commutes' := ⋯ } | true |
CategoryTheory.HasDetector.recOn | Mathlib.CategoryTheory.Generator.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{motive : CategoryTheory.HasDetector C → Sort u} →
(t : CategoryTheory.HasDetector C) → ((hasDetector : ∃ G, CategoryTheory.IsDetector G) → motive ⋯) → motive t | false |
Ideal.hasBasis_nhds_zero_adic | Mathlib.Topology.Algebra.Nonarchimedean.AdicTopology | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R), (nhds 0).HasBasis (fun _n => True) fun n => ↑(I ^ n) | true |
Std.DTreeMap.Raw.Const.unitOfList_equiv_foldl | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {l : List α},
(Std.DTreeMap.Raw.Const.unitOfList l cmp).Equiv (List.foldl (fun acc a => acc.insertIfNew a ()) ∅ l) | true |
Unitization.inrNonUnitalAlgHom_toFun | Mathlib.Algebra.Algebra.Unitization | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A] (a : A),
(Unitization.inrNonUnitalAlgHom R A) a = ↑a | true |
AbsoluteValue.map_units_intCast | Mathlib.Data.Int.AbsoluteValue | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : CommRing S] [inst_2 : LinearOrder S] [IsStrictOrderedRing S]
[Nontrivial R] (abv : AbsoluteValue R S) (x : ℤˣ), abv ↑↑x = 1 | true |
CategoryTheory.CommGrp.forget₂Grp_obj_X | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (A : CategoryTheory.CommGrp C),
((CategoryTheory.CommGrp.forget₂Grp C).obj A).X = A.X | true |
ContDiffBump.noConfusionType | Mathlib.Analysis.Calculus.BumpFunction.Basic | Sort u → {E : Type u_1} → {c : E} → ContDiffBump c → {E' : Type u_1} → {c' : E'} → ContDiffBump c' → Sort u | false |
List.foldrM_map | Init.Data.List.Monadic | ∀ {m : Type u_1 → Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {α : Type u_1} [inst : Monad m] [LawfulMonad m]
{f : β₁ → β₂} {g : β₂ → α → m α} {l : List β₁} {init : α},
List.foldrM g init (List.map f l) = List.foldrM (fun x y => g (f x) y) init l | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose_map_app_fst_app | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
(F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C B) {X : Type u₄} {Y : Type u₅}
[inst_3 : CategoryTheory.Category.{v₄, u... | true |
AddConstMap.«term_→+c[_,_]_» | Mathlib.Algebra.AddConstMap.Basic | Lean.TrailingParserDescr | true |
_private.Mathlib.Computability.TuringMachine.Config.0.Turing.ToPartrec.Code.exists_code._simp_1_17 | Mathlib.Computability.TuringMachine.Config | ∀ {α : Type u_1} {a b : α}, (b ∈ Part.some a) = (b = a) | false |
_private.Init.Data.List.Nat.Modify.0.List.eraseIdx_modify_of_lt._proof_1_1 | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} (f : α → α) (i j : ℕ) (l : List α), j < i → ∀ (k : ℕ), i - 1 = k → k < j → ¬i = k → False | false |
MeasureTheory.IsSigmaSubadditiveSetFun | Mathlib.MeasureTheory.Measure.PreVariation | {X : Type u_1} → [MeasurableSpace X] → (Set X → ENNReal) → Prop | true |
Lean.Elab.Tactic.evalSplit._regBuiltin.Lean.Elab.Tactic.evalSplit_1 | Lean.Elab.Tactic.Split | IO Unit | false |
PowerSeries.WithPiTopology.multipliable_one_add_of_tendsto_order_atTop_nhds_top | Mathlib.RingTheory.PowerSeries.PiTopology | ∀ (R : Type u_1) [inst : TopologicalSpace R] [inst_1 : CommSemiring R] {ι : Type u_2} [inst_2 : LinearOrder ι]
[LocallyFiniteOrderBot ι] {f : ι → PowerSeries R},
Filter.Tendsto (fun i => (f i).order) Filter.atTop (nhds ⊤) → Multipliable fun x => 1 + f x | true |
Valuation.Integers.not_denselyOrdered_of_isPrincipalIdealRing | Mathlib.RingTheory.Valuation.Integers | ∀ {F : Type u} {Γ₀ : Type v} [inst : Field F] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] {v : Valuation F Γ₀}
{O : Type w} [inst_2 : CommRing O] [inst_3 : Algebra O F] [IsPrincipalIdealRing O],
v.Integers O → ¬DenselyOrdered ↑(Set.range ⇑v) | true |
LinearMap.extendScalarsOfIsLocalizationEquiv_apply | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_3} [inst : CommSemiring R] (S : Submonoid R) (A : Type u_4) [inst_1 : CommSemiring A]
[inst_2 : Algebra R A] [inst_3 : IsLocalization S A] {M : Type u_5} {N : Type u_6} [inst_4 : AddCommMonoid M]
[inst_5 : Module R M] [inst_6 : Module A M] [inst_7 : IsScalarTower R A M] [inst_8 : AddCommMonoid N]
[i... | true |
Lean.Meta.Grind.Arith.CommRing.NonCommSemiringM.Context.semiringId | Lean.Meta.Tactic.Grind.Arith.CommRing.NonCommSemiringM | Lean.Meta.Grind.Arith.CommRing.NonCommSemiringM.Context → ℕ | true |
TopCat.GlueData.MkCore.t'._proof_7 | Mathlib.Topology.Gluing | ∀ (h : TopCat.GlueData.MkCore) (i j k : h.J),
Continuous fun x =>
⟨(⟨↑((CategoryTheory.ConcreteCategory.hom (h.t i j)) (↑x).1), ⋯⟩,
(CategoryTheory.ConcreteCategory.hom (h.t i j)) (↑x).1),
⋯⟩ | false |
Subalgebra.unop_iSup | Mathlib.Algebra.Algebra.Subalgebra.MulOpposite | ∀ {ι : Sort u_1} {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S : ι → Subalgebra R Aᵐᵒᵖ), (iSup S).unop = ⨆ i, (S i).unop | true |
List.max_le_of_forall_le | Mathlib.Data.List.MinMax | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : OrderBot α] (l : List α) (a : α),
(∀ x ∈ l, x ≤ a) → List.foldr max ⊥ l ≤ a | true |
sSupHom.mk.noConfusion | Mathlib.Order.Hom.CompleteLattice | {α : Type u_8} →
{β : Type u_9} →
{inst : SupSet α} →
{inst_1 : SupSet β} →
{P : Sort u} →
{toFun : α → β} →
{map_sSup' : ∀ (s : Set α), toFun (sSup s) = sSup (toFun '' s)} →
{toFun' : α → β} →
{map_sSup'' : ∀ (s : Set α), toFun' (sSup s) = sSup (t... | false |
Prod.snd_bot | Mathlib.Order.BoundedOrder.Basic | ∀ (α : Type u) (β : Type v) [inst : Bot α] [inst_1 : Bot β], ⊥.2 = ⊥ | true |
_private.Mathlib.Data.Ordmap.Invariants.0.Ordnode.Bounded.weak_right.match_1_1 | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} [inst : Preorder α]
(motive : (x : Ordnode α) → (x_1 : WithBot α) → (x_2 : WithTop α) → x.Bounded x_1 x_2 → Prop) (x : Ordnode α)
(x_1 : WithBot α) (x_2 : WithTop α) (x_3 : x.Bounded x_1 x_2),
(∀ (o₁ : WithBot α) (o₂ : WithTop α) (h : Ordnode.nil.Bounded o₁ o₂), motive Ordnode.nil o₁ o₂ h) →
... | false |
AList.erase.eq_1 | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (a : α) (s : AList β),
AList.erase a s = { entries := List.kerase a s.entries, nodupKeys := ⋯ } | true |
RingEquiv.map_neg_one | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_4} {S : Type u_5} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] (f : R ≃+* S), f (-1) = -1 | true |
Std.ExtTreeMap.get_union_of_not_mem_left | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
(not_mem : k ∉ t₁) {h' : k ∈ t₁ ∪ t₂}, (t₁ ∪ t₂).get k h' = t₂.get k ⋯ | true |
CategoryTheory.LaxMonoidalFunctor.hom_ext | Mathlib.CategoryTheory.Monoidal.NaturalTransformation | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F G : CategoryTheory.LaxMonoidalFunctor C D} {α β : F ⟶ G}, α.hom = β.hom → α = β | true |
Multiset.sum_map_sub | Mathlib.Algebra.BigOperators.Group.Multiset.Basic | ∀ {ι : Type u_2} {G : Type u_4} [inst : SubtractionCommMonoid G] {m : Multiset ι} {f g : ι → G},
(Multiset.map (fun i => f i - g i) m).sum = (Multiset.map f m).sum - (Multiset.map g m).sum | true |
Std.DTreeMap.Internal.RxcIterator.mk.noConfusion | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : α → Type v} →
{inst : Ord α} →
{P : Sort u_1} →
{iter : Std.DTreeMap.Internal.Zipper α β} →
{upper : α} →
{iter' : Std.DTreeMap.Internal.Zipper α β} →
{upper' : α} →
{ iter := iter, upper := upper } = { iter := iter', upper := u... | false |
_private.Mathlib.RingTheory.Valuation.Discrete.Basic.0.Valuation.Uniformizer.is_generator._simp_1_2 | Mathlib.RingTheory.Valuation.Discrete.Basic | (¬True) = False | false |
Order.pred_le_iff_eq_or_le | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : PredOrder α] {a b : α}, Order.pred b ≤ a ↔ a = Order.pred b ∨ b ≤ a | true |
Rat.instEncodable._proof_1 | Mathlib.Data.Rat.Encodable | ∀ (a : ℤ) (b : ℕ), b ≠ 0 → a.natAbs.Coprime b → 0 < b ∧ a.natAbs.Coprime b | false |
HomologicalComplex.mapBifunctor₂₃.d₁_eq | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₂₃ : Type u_4} {C₃ : Type u_5} {C₄ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_6} C₄]
[inst_4 : CategoryTheory.Category.{v_... | true |
_private.Mathlib.Geometry.Manifold.Notation.0.Manifold.Elab.findModelInner.fromCLM.match_1 | Mathlib.Geometry.Manifold.Notation | (motive : Lean.Expr × Lean.Expr × Lean.Expr → Sort u_1) →
(__discr : Lean.Expr × Lean.Expr × Lean.Expr) → ((k _E _F : Lean.Expr) → motive (k, _E, _F)) → motive __discr | false |
_private.Mathlib.Analysis.Meromorphic.Divisor.0.MeromorphicOn.divisor._simp_12 | Mathlib.Analysis.Meromorphic.Divisor | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | false |
ProofWidgets.RpcEncodablePacket._@.ProofWidgets.Presentation.Expr.4196812879._hygCtx._hyg.1 | ProofWidgets.Presentation.Expr | Type | false |
_private.Mathlib.Geometry.Euclidean.Sphere.SecondInter.0.EuclideanGeometry.Sphere.secondInter_map._simp_1_2 | Mathlib.Geometry.Euclidean.Sphere.SecondInter | ∀ {𝕜 : Type u_1} {V : Type u_2} {V₂ : Type u_5} {P : Type u_10} {P₂ : Type u_11} [inst : NormedField 𝕜]
[inst_1 : SeminormedAddCommGroup V] [inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P]
[inst_4 : NormedAddTorsor V P] [inst_5 : SeminormedAddCommGroup V₂] [inst_6 : NormedSpace 𝕜 V₂]
[inst_7 : Pseudo... | false |
Lean.PrettyPrinter.Parenthesizer.State.rec | Lean.PrettyPrinter.Parenthesizer | {motive : Lean.PrettyPrinter.Parenthesizer.State → Sort u} →
((stxTrav : Lean.Syntax.Traverser) →
(contPrec : Option ℕ) →
(contCat : Lean.Name) →
(minPrec trailPrec : Option ℕ) →
(trailCat : Lean.Name) →
(visitedToken : Bool) →
motive
... | false |
instSigmaCompactSpaceForallOfFinite | Mathlib.Topology.Compactness.SigmaCompact | ∀ {ι : Type u_3} [Finite ι] {X : ι → Type u_4} [inst : (i : ι) → TopologicalSpace (X i)]
[∀ (i : ι), SigmaCompactSpace (X i)], SigmaCompactSpace ((i : ι) → X i) | true |
AlgebraicGeometry.Scheme.Hom.image_le_image_iff | Mathlib.AlgebraicGeometry.OpenImmersion | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [inst : AlgebraicGeometry.IsOpenImmersion f] (U U' : X.Opens),
(AlgebraicGeometry.Scheme.Hom.opensFunctor f).obj U ≤ (AlgebraicGeometry.Scheme.Hom.opensFunctor f).obj U' ↔ U ≤ U' | true |
SignType | Mathlib.Data.Sign.Defs | Type | true |
Int8.toISize_lt._simp_1 | Init.Data.SInt.Lemmas | ∀ {a b : Int8}, (a.toISize < b.toISize) = (a < b) | false |
Multiset.fold_cons_left | Mathlib.Data.Multiset.Fold | ∀ {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] (b a : α) (s : Multiset α),
Multiset.fold op b (a ::ₘ s) = op a (Multiset.fold op b s) | true |
Lean.Elab.Tactic.Do.ProofMode.elabMExists._regBuiltin.Lean.Elab.Tactic.Do.ProofMode.elabMExists_1 | Lean.Elab.Tactic.Do.ProofMode.Refine | IO Unit | false |
UInt64.sub_eq_iff_eq_add | Init.Data.UInt.Lemmas | ∀ {a b c : UInt64}, a - b = c ↔ a = c + b | true |
VectorFourier.fderiv_fourierIntegral | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {V : Type u_2} {W : Type u_3}
[inst_2 : NormedAddCommGroup V] [inst_3 : NormedSpace ℝ V] [inst_4 : NormedAddCommGroup W] [inst_5 : NormedSpace ℝ W]
(L : V →L[ℝ] W →L[ℝ] ℝ) {f : V → E} [inst_6 : MeasurableSpace V] [BorelSpace V] [SecondCountab... | true |
CategoryTheory.Functor.CorepresentableBy.equivOfIsoObj_symm_apply | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {F : CategoryTheory.Functor C (Type w)} {X Y : C}
(e : Y ≅ X) (R : F.CorepresentableBy Y),
(CategoryTheory.Functor.CorepresentableBy.equivOfIsoObj e).symm R = R.ofIsoObj e.symm | true |
_private.Mathlib.Tactic.Cases.0.Mathlib.Tactic._aux_Mathlib_Tactic_Cases___elabRules_Mathlib_Tactic_induction'_1.match_4 | Mathlib.Tactic.Cases | (motive : Array Lean.Expr × Array (Lean.Ident × Lean.FVarId) → Sort u_1) →
(__discr : Array Lean.Expr × Array (Lean.Ident × Lean.FVarId)) →
((targets : Array Lean.Expr) → (toTag : Array (Lean.Ident × Lean.FVarId)) → motive (targets, toTag)) →
motive __discr | false |
CategoryTheory.SmallObject.SuccStruct.arrowι._proof_1 | Mathlib.CategoryTheory.SmallObject.Iteration.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1} [inst_1 : LinearOrder J]
[CategoryTheory.Limits.HasIterationOfShape J C] {i : J} (F : CategoryTheory.Functor (↑(Set.Iio i)) C),
Order.IsSuccLimit i → CategoryTheory.Limits.HasColimit F | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex.0.Finset.image_subset_iff._simp_1 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {t : Finset β},
(Finset.image f s ⊆ t) = ∀ x ∈ s, f x ∈ t | false |
HasFDerivWithinAt.congr' | Mathlib.Analysis.Calculus.FDeriv.Congr | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f f₁ : E → F} {f' : E →L[𝕜] F} {x : E} {s : Set E},
HasFDerivWithinAt ... | true |
monovary_id_iff._simp_1 | Mathlib.Order.Monotone.Monovary | ∀ {ι : Type u_1} {α : Type u_3} [inst : Preorder α] {f : ι → α} [inst_1 : PartialOrder ι], Monovary f id = Monotone f | false |
gaugeSeminormFamily_ball | Mathlib.Analysis.LocallyConvex.AbsConvexOpen | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E]
[inst_3 : Module 𝕜 E] [inst_4 : Module ℝ E] [inst_5 : IsScalarTower ℝ 𝕜 E] [inst_6 : ContinuousSMul ℝ E]
(s : AbsConvexOpenSets 𝕜 E), (gaugeSeminormFamily 𝕜 E s).ball 0 1 = ↑s | true |
InfHom.coe_mk | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Min α] [inst_1 : Min β] (f : α → β) (hf : ∀ (a b : α), f (a ⊓ b) = f a ⊓ f b),
⇑{ toFun := f, map_inf' := hf } = f | true |
List.lawfulBEq_iff | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α], LawfulBEq (List α) ↔ LawfulBEq α | true |
Set.uIoc_injective_left | Mathlib.Order.Interval.Set.UnorderedInterval | ∀ {α : Type u_1} [inst : LinearOrder α] (a : α), Function.Injective (Set.uIoc a) | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxOf_eq_idxOfNth_add._proof_1_2 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} [inst : BEq α] {n s : ℕ} (h : n + 1 ≤ (List.idxsOf x [] s).length),
(List.idxsOf x [] s)[n] - s < [].length | false |
AlgebraicGeometry.Scheme.stalkMap_inv_hom_apply | Mathlib.AlgebraicGeometry.Scheme | ∀ {X Y : AlgebraicGeometry.Scheme} (e : X ≅ Y) (x : ↥X) (y : ↑(X.presheaf.stalk (e.inv (e.hom x)))),
(CategoryTheory.ConcreteCategory.hom (AlgebraicGeometry.Scheme.Hom.stalkMap e.hom x))
((CategoryTheory.ConcreteCategory.hom (AlgebraicGeometry.Scheme.Hom.stalkMap e.inv (e.hom x))) y) =
(CategoryTheory.Concr... | true |
Finset.sum_smul | Mathlib.Algebra.Module.BigOperators | ∀ {ι : Type u_1} {R : Type u_5} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{f : ι → R} {s : Finset ι} {x : M}, (∑ i ∈ s, f i) • x = ∑ i ∈ s, f i • x | true |
_private.Mathlib.RingTheory.RingHom.Integral.0.RingHom.isIntegral_ofLocalizationSpan._simp_1_7 | Mathlib.RingTheory.RingHom.Integral | ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : Monoid G] [inst_2 : Monoid H]
[MonoidHomClass F G H] (f : F) (a : G) (n : ℕ), f a ^ n = f (a ^ n) | false |
_private.Mathlib.Order.RelSeries.0.LTSeries.apply_add_index_le_apply_add_index_int._proof_1_7 | Mathlib.Order.RelSeries | ∀ (p : LTSeries ℤ) (j : ℕ), j + 1 < p.length + 1 → j < p.length | false |
SuccAddOrder.toSuccOrder | Mathlib.Algebra.Order.SuccPred | {α : Type u_1} → {inst : Preorder α} → {inst_1 : Add α} → {inst_2 : One α} → [self : SuccAddOrder α] → SuccOrder α | true |
Std.Tactic.BVDecide.LRAT.Internal.Clause.isUnit_iff | Std.Tactic.BVDecide.LRAT.Internal.Clause | ∀ {α : outParam (Type u)} {β : Type v} [self : Std.Tactic.BVDecide.LRAT.Internal.Clause α β] (c : β)
(l : Std.Sat.Literal α),
Std.Tactic.BVDecide.LRAT.Internal.Clause.isUnit c = some l ↔ Std.Tactic.BVDecide.LRAT.Internal.Clause.toList c = [l] | true |
RingEquiv.toSemiRingCatIso._proof_3 | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : Type u_1} [inst : Semiring R] [inst_1 : Semiring S], RingHomClass (S ≃+* R) S R | false |
Profinite.NobelingProof.continuous_CC'₁ | Mathlib.Topology.Category.Profinite.Nobeling.Successor | ∀ {I : Type u} (C : Set (I → Bool)) [inst : LinearOrder I] [inst_1 : WellFoundedLT I] {o : Ordinal.{u}}
(hsC : Profinite.NobelingProof.contained C (Order.succ o)) (ho : o < Ordinal.type fun x1 x2 => x1 < x2),
Continuous (Profinite.NobelingProof.CC'₁ C hsC ho) | true |
Equiv.eq_conj | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_11} {α' : Sort u_12} {β : Sort u_13} {β' : Sort u_14} (ε₁ : α ≃ α') (ε₂ : β' ≃ β) (f : α → β)
(f' : α' → β'), ⇑ε₂.symm ∘ f ∘ ⇑ε₁.symm = f' ↔ f = ⇑ε₂ ∘ f' ∘ ⇑ε₁ | true |
MvPowerSeries.substAlgHom_coe | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommRing R] {τ : Type u_4} {S : Type u_5} [inst_1 : CommRing S]
[inst_2 : Algebra R S] {a : σ → MvPowerSeries τ S} (ha : MvPowerSeries.HasSubst a) (p : MvPolynomial σ R),
(MvPowerSeries.substAlgHom ha) ↑p = (MvPolynomial.aeval a) p | true |
_private.Lean.Meta.Match.MatchEqs.0.Lean.Meta.Match.initFn._@.Lean.Meta.Match.MatchEqs.3248161880._hygCtx._hyg.2 | Lean.Meta.Match.MatchEqs | IO Unit | false |
EuclideanDomain.mul_div_cancel' | Mathlib.Algebra.EuclideanDomain.Basic | ∀ {R : Type u} [inst : EuclideanDomain R] {a b : R}, b ≠ 0 → b ∣ a → b * (a / b) = a | true |
Turing.Dir.left.sizeOf_spec | Mathlib.Computability.TuringMachine.Tape | sizeOf Turing.Dir.left = 1 | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_40 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] (w : α),
List.idxOfNth w [] 0 + 1 ≤ (List.filter (fun x => decide (x = w)) []).length →
List.idxOfNth w [] 0 < (List.filter (fun x => decide (x = w)) []).length | false |
_private.Mathlib.Data.Set.Card.0.Set.Finite.exists_injOn_of_encard_le._simp_1_12 | Mathlib.Data.Set.Card | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | false |
Associates | Mathlib.Algebra.GroupWithZero.Associated | (M : Type u_2) → [Monoid M] → Type u_2 | true |
Lean.ParametricAttribute.mk._flat_ctor | Lean.Attributes | {α : Type} →
Lean.AttributeImpl →
Lean.PersistentEnvExtension (Lean.Name × α) (Lean.Name × α) (List Lean.Name × Lean.NameMap α) →
Bool → Lean.ParametricAttribute α | false |
SimpleGraph.ConnectedComponent.even_card_of_isPerfectMatching | Mathlib.Combinatorics.SimpleGraph.Matching | ∀ {V : Type u_1} {G : SimpleGraph V} {M : G.Subgraph} [inst : Fintype V] [inst_1 : DecidableEq V]
[inst_2 : DecidableRel G.Adj] (c : G.ConnectedComponent), M.IsPerfectMatching → Even (Fintype.card ↑c.supp) | true |
MulOpposite.instInvolutiveNeg | Mathlib.Algebra.Opposites | {α : Type u_1} → [InvolutiveNeg α] → InvolutiveNeg αᵐᵒᵖ | true |
IsPowMul.restriction | Mathlib.Analysis.Normed.Ring.Basic | ∀ {R : Type u_5} {S : Type u_6} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] (A : Subalgebra R S)
{f : S → ℝ}, IsPowMul f → IsPowMul fun x => f ↑x | true |
FiniteDimensional.basisSingleton._proof_6 | Mathlib.LinearAlgebra.FiniteDimensional.Basic | ∀ {K : Type u_1} [inst : DivisionRing K], RingHomInvPair (RingHom.id K) (RingHom.id K) | false |
AlgebraicGeometry.Scheme.Hom.map_appLE'_assoc | Mathlib.AlgebraicGeometry.Scheme | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) {U U' : Y.Opens} {V : X.Opens}
(e : V ≤ (TopologicalSpace.Opens.map f.base).obj U) (i : U' = U) {Z : CommRingCat}
(h : X.presheaf.obj (Opposite.op V) ⟶ Z),
CategoryTheory.CategoryStruct.comp (Y.presheaf.map (CategoryTheory.eqToHom i).op)
(CategoryTheory.Categor... | true |
Aesop.runTacticMAsElabM | Aesop.RuleTac.ElabRuleTerm | {α : Type} → Lean.Elab.Tactic.TacticM α → Aesop.ElabM α | true |
Filter.Germ.instDivisionSemiring._proof_6 | Mathlib.Order.Filter.FilterProduct | ∀ {α : Type u_2} {β : Type u_1} {φ : Ultrafilter α} [DivisionSemiring β], Nontrivial ((↑φ).Germ β) | false |
Cardinal.mul_natCast_le_mul_natCast._simp_1 | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {n : ℕ} {a b : Cardinal.{u_1}}, n ≠ 0 → (a * ↑n ≤ b * ↑n) = (a ≤ b) | false |
Mathlib.Tactic.Choose.ElimStatus.ctorIdx | Mathlib.Tactic.Choose | Mathlib.Tactic.Choose.ElimStatus → ℕ | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.