name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Compiler.LCNF.SpecEntry.mk.noConfusion | Lean.Compiler.LCNF.SpecInfo | {P : Sort u} →
{declName : Lean.Name} →
{paramsInfo : Array Lean.Compiler.LCNF.SpecParamInfo} →
{alreadySpecialized : Bool} →
{declName' : Lean.Name} →
{paramsInfo' : Array Lean.Compiler.LCNF.SpecParamInfo} →
{alreadySpecialized' : Bool} →
{ declName := declName, ... | false |
Batteries.RBNode.lowerBound? | Batteries.Data.RBMap.Basic | {α : Type u_1} → (α → Ordering) → Batteries.RBNode α → optParam (Option α) none → Option α | true |
Lean.Meta.Grind.Arith.propagateNatXOr | Lean.Meta.Tactic.Grind.Arith.Propagate | Lean.Meta.Grind.Propagator | true |
Subring.mk.injEq | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u} [inst : NonAssocRing R] (toSubsemiring : Subsemiring R)
(neg_mem' : ∀ {x : R}, x ∈ toSubsemiring.carrier → -x ∈ toSubsemiring.carrier) (toSubsemiring_1 : Subsemiring R)
(neg_mem'_1 : ∀ {x : R}, x ∈ toSubsemiring_1.carrier → -x ∈ toSubsemiring_1.carrier),
({ toSubsemiring := toSubsemiring, neg_mem' ... | true |
_private.Mathlib.CategoryTheory.Sites.Coherent.RegularTopology.0.CategoryTheory.regularTopology.instEffectiveEpiComp.match_3 | Mathlib.CategoryTheory.Sites.Coherent.RegularTopology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (π : Y ⟶ X) ⦃V : C⦄ ⦃f : V ⟶ X⦄
(motive :
(CategoryTheory.Sieve.generate
(CategoryTheory.Presieve.ofArrows (fun x => Y) fun x =>
match x with
| PUnit.unit => π)).arrows
f →
Prop)
(h :
... | false |
Lean.Meta.AuxLemmas.mk.sizeOf_spec | Lean.Meta.Tactic.AuxLemma | ∀ (lemmas : Lean.PHashMap Lean.Meta.AuxLemmaKey (Lean.Name × List Lean.Name)),
sizeOf { lemmas := lemmas } = 1 + sizeOf lemmas | true |
Lean.PrettyPrinter.Delaborator.delabSort | Lean.PrettyPrinter.Delaborator.Builtins | Lean.PrettyPrinter.Delaborator.Delab | true |
AddLocalization.decidableEq.eq_1 | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : IsCancelAdd α] {s : AddSubmonoid α} [inst_2 : DecidableEq α]
(a b : AddLocalization s),
a.decidableEq b = a.recOnSubsingleton₂ b fun x x_1 x_2 x_3 => decidable_of_iff' (↑x_3 + x = ↑x_2 + x_1) ⋯ | true |
Filter.eventually_and | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
(∀ᶠ (x : α) in f, p x ∧ q x) ↔ (∀ᶠ (x : α) in f, p x) ∧ ∀ᶠ (x : α) in f, q x | true |
Set.range_inl | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2}, Set.range Sum.inl = {x | x.isLeft = true} | true |
NonUnitalSubsemiring.comap | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | {R : Type u} →
{S : Type v} →
[inst : NonUnitalNonAssocSemiring R] →
[inst_1 : NonUnitalNonAssocSemiring S] →
{F : Type u_1} →
[inst_2 : FunLike F R S] → [NonUnitalRingHomClass F R S] → F → NonUnitalSubsemiring S → NonUnitalSubsemiring R | true |
FirstOrder.Language.graphRel.noConfusion | Mathlib.ModelTheory.Graph | {P : Sort u} →
{a : ℕ} →
{t : FirstOrder.Language.graphRel a} →
{a' : ℕ} →
{t' : FirstOrder.Language.graphRel a'} → a = a' → t ≍ t' → FirstOrder.Language.graphRel.noConfusionType P t t' | false |
_private.Lean.Meta.Tactic.Grind.MBTC.0.Lean.Meta.Grind.ArgInfo.rec | Lean.Meta.Tactic.Grind.MBTC | {motive : Lean.Meta.Grind.ArgInfo✝ → Sort u} →
((arg app : Lean.Expr) → motive { arg := arg, app := app }) → (t : Lean.Meta.Grind.ArgInfo✝¹) → motive t | false |
PFunctor.M.casesOn_mk' | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} {r : F.M → Sort u_2} {a : F.A} (x : F.B a → F.M)
(f : (a : F.A) → (f : F.B a → F.M) → r (PFunctor.M.mk ⟨a, f⟩)), (PFunctor.M.mk ⟨a, x⟩).casesOn' f = f a x | true |
Std.Do.PostShape.noConfusion | Std.Do.PostCond | {P : Sort u_1} → {t t' : Std.Do.PostShape} → t = t' → Std.Do.PostShape.noConfusionType P t t' | false |
Subfield._sizeOf_inst | Mathlib.Algebra.Field.Subfield.Defs | (K : Type u) → {inst : DivisionRing K} → [SizeOf K] → SizeOf (Subfield K) | false |
_private.Mathlib.Topology.Algebra.WithZeroTopology.0.WithZeroTopology.orderClosedTopology._simp_2 | Mathlib.Topology.Algebra.WithZeroTopology | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | false |
ContDiffAt.smulRight | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {x : E} {n : WithTop ℕ∞} {f : E → Str... | true |
Equiv.image_swap_of_mem_of_notMem | Mathlib.Logic.Equiv.Basic | ∀ {α : Type u_9} [inst : DecidableEq α] {s : Set α} {i j : α}, i ∈ s → j ∉ s → ⇑(Equiv.swap i j) '' s = insert j s \ {i} | true |
CategoryTheory.Limits.PullbackCone.flipIsLimit._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
{t : CategoryTheory.Limits.PullbackCone f g} (ht : CategoryTheory.Limits.IsLimit t)
(s : CategoryTheory.Limits.PullbackCone g f),
CategoryTheory.CategoryStruct.comp ((fun s => ht.lift s.flip) s) t.snd = s.fst | false |
Lean.PrettyPrinter.Parenthesizer.checkColGt.parenthesizer | Lean.PrettyPrinter.Parenthesizer | Lean.PrettyPrinter.Parenthesizer | true |
rootsOfUnityUnitsMulEquiv._proof_6 | Mathlib.RingTheory.RootsOfUnity.Basic | ∀ (M : Type u_1) [inst : CommMonoid M] (n : ℕ) (ζ ζ' : ↥(rootsOfUnity n Mˣ)), ⟨↑↑(ζ * ζ'), ⋯⟩ = ⟨↑↑ζ, ⋯⟩ * ⟨↑↑ζ', ⋯⟩ | false |
WithLp.toLp_fst | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ {p : ENNReal} {α : Type u_2} {β : Type u_3} (x : α × β), (WithLp.toLp p x).fst = x.1 | true |
_private.Mathlib.Data.List.Basic.0.List.length_eq_two'._proof_1_20 | Mathlib.Data.List.Basic | ∀ {α : Type u_1} {l : List α} (h : l ≠ []),
-1 * ↑l.length + 1 ≤ 0 → l = [l.head ⋯, l.getLast ⋯] → 0 < [l.head ⋯, l.getLast ⋯].length | false |
Fintype.prod_eq_mul | Mathlib.Data.Fintype.BigOperators | ∀ {α : Type u_1} {M : Type u_4} [inst : Fintype α] [inst_1 : CommMonoid M] {f : α → M} (a b : α),
a ≠ b → (∀ (x : α), x ≠ a ∧ x ≠ b → f x = 1) → ∏ x, f x = f a * f b | true |
_private.Lean.Meta.MethodSpecs.0.Lean.rewriteThm | Lean.Meta.MethodSpecs | Lean.Meta.Simp.Context → Lean.Meta.Simprocs → Lean.Name → Lean.Name → Lean.MetaM Unit | true |
geom_sum_Ico_mul_neg | Mathlib.Algebra.Ring.GeomSum | ∀ {R : Type u_1} [inst : Ring R] (x : R) {m n : ℕ}, m ≤ n → (∑ i ∈ Finset.Ico m n, x ^ i) * (1 - x) = x ^ m - x ^ n | true |
Nat.reducePow | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | Lean.Meta.Simp.DSimproc | true |
_private.Mathlib.FieldTheory.RatFunc.Luroth.0.RatFunc.Luroth.Φ_coeff_generatorIndex_ne_zero | Mathlib.FieldTheory.RatFunc.Luroth | ∀ {K : Type u_1} [inst : Field K] {E : IntermediateField K (RatFunc K)} (h : E ≠ ⊥),
(RatFunc.Luroth.Φ✝ E).coeff (RatFunc.Luroth.generatorIndex✝ h) ≠ 0 | true |
CategoryTheory.GrothendieckTopology.Point.toPresheafFiberOfIsCofiltered_naturality_assoc | Mathlib.CategoryTheory.Sites.Point.OfIsCofiltered | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.LocallySmall.{w, v, u} C]
{N : Type u'} [inst_2 : CategoryTheory.Category.{v', u'} N] (p : CategoryTheory.Functor N C)
[inst_3 : CategoryTheory.InitiallySmall N] {J : CategoryTheory.GrothendieckTopology C}
[inst_4 : CategoryTheory.I... | true |
Multiset.mem_filterMap | Mathlib.Data.Multiset.Filter | ∀ {α : Type u_1} {β : Type v} (f : α → Option β) (s : Multiset α) {b : β},
b ∈ Multiset.filterMap f s ↔ ∃ a ∈ s, f a = some b | true |
Algebra.RingHom.adjoinAlgebraMapEquiv._proof_1 | Mathlib.RingTheory.Adjoin.Singleton | ∀ {A : Type u_2} {B : Type u_1} [inst : CommSemiring A] [inst_1 : CommSemiring B] [inst_2 : Algebra A B] (b : B)
(p : Polynomial A), (Polynomial.aeval b) p ∈ A[b] | false |
Polynomial.coeff_ofFinsupp | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (p : AddMonoidAlgebra R ℕ), { toFinsupp := p }.coeff = ⇑p | true |
AdjoinRoot.equiv'._proof_2 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_2} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (g : Polynomial R)
(pb : PowerBasis R S) (h₁ : (Polynomial.aeval (AdjoinRoot.root g)) (minpoly R pb.gen) = 0)
(h₂ : (Polynomial.aeval pb.gen) g = 0) (x : S),
(AdjoinRoot.liftAlgHom g (Algebra.ofId R S) pb.gen h₂) ((pb... | false |
Localization.subalgebra.isFractionRing | Mathlib.RingTheory.Localization.AsSubring | ∀ {A : Type u_1} (K : Type u_2) [inst : CommRing A] (S : Submonoid A) (hS : S ≤ nonZeroDivisors A) [inst_1 : CommRing K]
[inst_2 : Algebra A K] [inst_3 : IsFractionRing A K], IsFractionRing (↥(Localization.subalgebra K S hS)) K | true |
Int16.toInt64_lt._simp_1 | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, (a.toInt64 < b.toInt64) = (a < b) | false |
Ideal.Quotient.stabilizerHomSurjectiveAuxFunctor | Mathlib.RingTheory.Invariant.Profinite | {A : Type u_1} →
{B : Type u_2} →
[inst : CommRing A] →
[inst_1 : CommRing B] →
[inst_2 : Algebra A B] →
{G : Type u_3} →
[inst_3 : Group G] →
[inst_4 : MulSemiringAction G B] →
[SMulCommClass G A B] →
[inst_6 : TopologicalSpace G... | true |
SetLike.Homogeneous.smul | Mathlib.Algebra.DirectSum.Internal | ∀ {ι : Type u_1} {S : Type u_3} {R : Type u_4} [inst : CommSemiring S] [inst_1 : Semiring R] [inst_2 : Algebra S R]
{A : ι → Submodule S R} {s : S} {r : R}, SetLike.IsHomogeneousElem A r → SetLike.IsHomogeneousElem A (s • r) | true |
jacobiTheta₂'_term | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | ℤ → ℂ → ℂ → ℂ | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getD_eq_fallback_of_contains_eq_false._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
CategoryTheory.AB5StarOfSize.rec | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasCofilteredLimitsOfSize.{w, w', v, u} C] →
{motive : CategoryTheory.AB5StarOfSize.{w, w', v, u} C → Sort u_1} →
((ofShape :
∀ (J : Type w') [inst_2 : CategoryTheory.Category.{w, w'} J] [inst_3 ... | false |
Lean.Server.Test.Runner.Client.MsgEmbed.trace.injEq | Lean.Server.Test.Runner | ∀ (indent : ℕ) (cls : Lean.Name) (msg : Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed)
(collapsed : Bool)
(children :
Lean.Server.Test.Runner.Client.StrictOrLazy (Array (Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed))
Lean.Lsp.RpcRef)
(indent_1 : ℕ) (cls_1 : Lean.Name) ... | true |
VectorBundleCore.trivializationAt_coordChange_eq | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField R] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace R F] [inst_3 : TopologicalSpace B] {ι : Type u_5} (Z : VectorBundleCore R B F ι) {b₀ b₁ b : B},
b ∈ (trivializationAt F Z.Fiber b₀).baseSet ∩ (trivializationAt F Z.Fiber b₁).baseSe... | true |
Aesop.EqualUpToIds.MVarValue._sizeOf_inst | Aesop.Util.EqualUpToIds | SizeOf Aesop.EqualUpToIds.MVarValue | false |
Std.Net.InterfaceAddress.address | Std.Net.Addr | Std.Net.InterfaceAddress → Std.Net.IPAddr | true |
Lean.Doc.elabInline._unsafe_rec | Lean.Elab.DocString | Lean.TSyntax `inline → Lean.Doc.DocM (Lean.Doc.Inline Lean.ElabInline) | false |
AdjoinRoot.algEquivOfAssociated_symm | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (f g : Polynomial S)
(hfg : Associated f g), (AdjoinRoot.algEquivOfAssociated R f g hfg).symm = AdjoinRoot.algEquivOfAssociated R g f ⋯ | true |
Lean.MonadTrace.getTraceState | Lean.Util.Trace | {m : Type → Type} → [self : Lean.MonadTrace m] → m Lean.TraceState | true |
ConditionallyCompleteLinearOrder.toSuccOrder | Mathlib.Order.SuccPred.CompleteLinearOrder | {α : Type u_2} → [inst : ConditionallyCompleteLinearOrder α] → [WellFoundedLT α] → SuccOrder α | true |
Std.TreeSet.Raw.min!_eq_default | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.WF → t.isEmpty = true → t.min! = default | true |
IO.FS.createDir | Init.System.IO | System.FilePath → IO Unit | true |
_private.Mathlib.MeasureTheory.OuterMeasure.Caratheodory.0.MeasureTheory.OuterMeasure.isCaratheodory_iUnion_lt.match_1_1 | Mathlib.MeasureTheory.OuterMeasure.Caratheodory | ∀ {α : Type u_1} (m : MeasureTheory.OuterMeasure α) {s : ℕ → Set α}
(motive : (x : ℕ) → (∀ i < x, m.IsCaratheodory (s i)) → Prop) (x : ℕ) (x_1 : ∀ i < x, m.IsCaratheodory (s i)),
(∀ (x : ∀ i < 0, m.IsCaratheodory (s i)), motive 0 x) →
(∀ (n : ℕ) (h : ∀ i < n + 1, m.IsCaratheodory (s i)), motive n.succ h) → moti... | false |
_private.Mathlib.Geometry.Euclidean.Congruence.0.EuclideanGeometry.angle_angle_side._proof_1_2 | Mathlib.Geometry.Euclidean.Congruence | ∀ {V₁ : Type u_3} {V₂ : Type u_1} {P₁ : Type u_4} {P₂ : Type u_2} [inst : NormedAddCommGroup V₁]
[inst_1 : NormedAddCommGroup V₂] [inst_2 : InnerProductSpace ℝ V₁] [inst_3 : InnerProductSpace ℝ V₂]
[inst_4 : MetricSpace P₁] [inst_5 : MetricSpace P₂] [inst_6 : NormedAddTorsor V₁ P₁] [inst_7 : NormedAddTorsor V₂ P₂]
... | false |
_private.Lean.Util.LeanOptions.0.Lean.LeanOptions.toOptions.match_1 | Lean.Util.LeanOptions | (motive : Lean.Name × Lean.LeanOptionValue → Sort u_1) →
(x : Lean.Name × Lean.LeanOptionValue) →
((name : Lean.Name) → (optionValue : Lean.LeanOptionValue) → motive (name, optionValue)) → motive x | false |
Std.ExtDHashMap.Const.getKey!_filterMap | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {γ : Type w} {m : Std.ExtDHashMap α fun x => β}
[inst : EquivBEq α] [inst_1 : LawfulHashable α] [inst_2 : Inhabited α] {f : α → β → Option γ} {k : α},
(Std.ExtDHashMap.filterMap f m).getKey! k =
((m.getKey? k).pfilter fun x_2 h' => (f x_2 (Std.ExtDHashM... | true |
BoundedContinuousFunction.coeFn_toLp | Mathlib.MeasureTheory.Function.LpSpace.ContinuousFunctions | ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} (p : ENNReal) (μ : MeasureTheory.Measure α)
[inst : TopologicalSpace α] [inst_1 : BorelSpace α] [inst_2 : NormedAddCommGroup E]
[inst_3 : SecondCountableTopologyEither α E] [inst_4 : MeasureTheory.IsFiniteMeasure μ] (𝕜 : Type u_3)
[inst_5 : Fact (1 ≤ p)] [... | true |
Cauchy.eq_1 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} [uniformSpace : UniformSpace α] (f : Filter α), Cauchy f = (f.NeBot ∧ f ×ˢ f ≤ uniformity α) | true |
CategoryTheory.Over.postAdjunctionRight._proof_6 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} T] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {Y : D} {F : CategoryTheory.Functor T D}
{G : CategoryTheory.Functor D T} (a : F ⊣ G) (A : CategoryTheory.Over ((CategoryTheory.Functor.id D).obj Y)),
CategoryTheory.CategoryStruct.comp (a... | false |
Vector.mapFinIdx_append._proof_4 | Init.Data.Vector.MapIdx | ∀ {n m : ℕ}, ∀ i < m, i + n < n + m | false |
Matrix.kroneckerTMulStarAlgEquiv_symm_apply | Mathlib.RingTheory.MatrixAlgebra | ∀ {m : Type u_2} {n : Type u_3} (R : Type u_5) (S : Type u_6) {A : Type u_7} {B : Type u_8} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Fintype n]
[inst_6 : DecidableEq n] [inst_7 : CommSemiring S] [inst_8 : Algebra R S] [inst_9 : Algeb... | true |
FirstOrder.Language.PartialEquiv.toEmbeddingOfEqTop | Mathlib.ModelTheory.PartialEquiv | {L : FirstOrder.Language} →
{M : Type w} →
{N : Type w'} →
[inst : L.Structure M] → [inst_1 : L.Structure N] → {f : L.PartialEquiv M N} → f.dom = ⊤ → L.Embedding M N | true |
_private.Mathlib.Analysis.SpecialFunctions.Log.RpowTendsto.0.Real.tendstoLocallyUniformlyOn_rpow_sub_one_log._proof_1_12 | Mathlib.Analysis.SpecialFunctions.Log.RpowTendsto | ∀ (p : ℝ), 0 < p → 0 ≤ p⁻¹ | false |
Function.Periodic.eq_1 | Mathlib.Algebra.Ring.Periodic | ∀ {α : Type u_1} {β : Type u_2} [inst : Add α] (f : α → β) (c : α), Function.Periodic f c = ∀ (x : α), f (x + c) = f x | true |
AddMonoidHom.codRestrict | Mathlib.Algebra.Group.Submonoid.Operations | {M : Type u_1} →
{N : Type u_2} →
[inst : AddZeroClass M] →
[inst_1 : AddZeroClass N] →
{S : Type u_5} →
[inst_2 : SetLike S N] →
[inst_3 : AddSubmonoidClass S N] → (f : M →+ N) → (s : S) → (∀ (x : M), f x ∈ s) → M →+ ↥s | true |
_private.Init.Data.Array.Extract.0.Array.extract_size_left._proof_1_1 | Init.Data.Array.Extract | ∀ {α : Type u_1} {j : ℕ} {as : Array α}, ¬min j as.size ≤ as.size → False | false |
quotAdjoinEquivQuotMap._proof_2 | Mathlib.RingTheory.Conductor | ∀ {R : Type u_2} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S], RingHomClass (R →+* S) R S | false |
CategoryTheory.functorProdFunctorEquivUnitIso | Mathlib.CategoryTheory.Products.Basic | (A : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
(B : Type u₂) →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
(C : Type u₃) →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
CategoryTheory.Functor.id (CategoryTheory.Functor A B × CategoryTheory.Functor A C) ≅
... | true |
_private.Mathlib.NumberTheory.Ostrowski.0.Rat.AbsoluteValue.equiv_padic_of_bounded._simp_1_6 | Mathlib.NumberTheory.Ostrowski | ∀ {x : ℝ}, 0 ≤ x → ∀ (y z : ℝ), (x ^ y) ^ z = x ^ (y * z) | false |
CategoryTheory.instDecidableEqPairwise.decEq._proof_2 | Mathlib.CategoryTheory.Category.Pairwise | ∀ {ι : Type u_1} (a a_1 : ι), CategoryTheory.Pairwise.pair a a_1 = CategoryTheory.Pairwise.pair a a_1 | false |
Int.getD_toList_roo_eq_fallback | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n fallback : ℤ} {i : ℕ}, (n - (m + 1)).toNat ≤ i → (m<...n).toList.getD i fallback = fallback | true |
Nat.instMonoidWithZero | Mathlib.Algebra.GroupWithZero.Nat | MonoidWithZero ℕ | true |
Array.any_flatten' | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {stop : ℕ} {f : α → Bool} {xss : Array (Array α)},
stop = xss.flatten.size → xss.flatten.any f 0 stop = xss.any fun x => x.any f | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform.0.CategoryTheory.Limits.CatCospanTransform.instIsIsoWhiskerRight._simp_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {A' : Type u₄} {B' : Type u₅} {C' : Type u₆} {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 : Categ... | false |
CategoryTheory.MonoOver.imageMonoOver | Mathlib.CategoryTheory.Subobject.MonoOver | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y : C} → (f : X ⟶ Y) → [CategoryTheory.Limits.HasImage f] → CategoryTheory.MonoOver Y | true |
fintypeAffineCoords.eq_1 | Mathlib.LinearAlgebra.AffineSpace.Basis | ∀ (ι : Type u_1) (k : Type u_2) [inst : Ring k] [inst_1 : Fintype ι],
fintypeAffineCoords ι k = AffineSubspace.comap (Fintype.linearCombination k 1).toAffineMap (affineSpan k {1}) | true |
Lean.PrettyPrinter.Delaborator.delabNeg | Lean.PrettyPrinter.Delaborator.Builtins | Lean.PrettyPrinter.Delaborator.Delab | true |
Filter.Tendsto.inseparable_iff_uniformity | Mathlib.Topology.UniformSpace.Separation | ∀ {α : Type u} [inst : UniformSpace α] {β : Type u_1} {l : Filter β} [l.NeBot] {f g : β → α} {a b : α},
Filter.Tendsto f l (nhds a) →
Filter.Tendsto g l (nhds b) → (Inseparable a b ↔ Filter.Tendsto (fun x => (f x, g x)) l (uniformity α)) | true |
_private.Mathlib.Topology.Algebra.AsymptoticCone.0.zero_mem_asymptoticCone._simp_1_1 | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {α : Type u} {s : Set α}, (¬s.Nonempty) = (s = ∅) | false |
CategoryTheory.Functor.structuredArrowMapCone._proof_1 | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_3} {D : Type u_4} {H : Type u_6} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] [inst_2 : CategoryTheory.Category.{u_5, u_6} H]
(L : CategoryTheory.Functor C D) (F : CategoryTheory.Functor C H) (G : CategoryTheory.Functor D H) (α : L.comp G ⟶ F)
(Y : D)... | false |
MeasureTheory.tsum_meas_le_meas_iUnion_of_disjoint | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {ι : Type u_8} {x : MeasurableSpace α} (μ : MeasureTheory.Measure α) {As : ι → Set α},
(∀ (i : ι), MeasurableSet (As i)) → Pairwise (Function.onFun Disjoint As) → ∑' (i : ι), μ (As i) ≤ μ (⋃ i, As i) | true |
SubMulAction.ofStabilizer.conjMap._proof_4 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | ∀ {G : Type u_2} [inst : Group G] {α : Type u_1} [inst_1 : MulAction G α] {g : G} {a b : α},
b = g • a → ∀ (x : ↥(MulAction.stabilizer G a)) (x_1 : ↥(SubMulAction.ofStabilizer G a)), g • ↑(x • x_1) ∈ {b} → False | false |
RegularExpression.matches'.eq_def | Mathlib.Computability.RegularExpressions | ∀ {α : Type u_1} (x : RegularExpression α),
x.matches' =
match x with
| RegularExpression.zero => 0
| RegularExpression.epsilon => 1
| RegularExpression.char a => {[a]}
| P.plus Q => P.matches' + Q.matches'
| P.comp Q => P.matches' * Q.matches'
| P.star => KStar.kstar P.matches' | true |
_private.Init.Data.Array.Lemmas.0.Array.all_toList._simp_1_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {a : α} {l : List α}, (a ∈ l) = ∃ i, ∃ (h : i < l.length), l[i] = a | false |
Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticStop__1 | Init.Tactics | Lean.Macro | false |
Finset.eventually_cocardinal_notMem | Mathlib.Order.Filter.Cocardinal | ∀ {α : Type u} {c : Cardinal.{u}} {hreg : c.IsRegular} (s : Finset α), ∀ᶠ (x : α) in Filter.cocardinal α hreg, x ∉ s | true |
star_mul_self_nonneg._simp_1 | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
(r : R), (0 ≤ star r * r) = True | false |
Multiset.dedup_cons_of_mem | Mathlib.Data.Multiset.Dedup | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, a ∈ s → (a ::ₘ s).dedup = s.dedup | true |
String.Pos.find? | Init.Data.String.Search | {ρ : Type} →
{σ : String.Slice → Type} →
[inst : (s : String.Slice) → Std.Iterator (σ s) Id (String.Slice.Pattern.SearchStep s)] →
[(s : String.Slice) → Std.IteratorLoop (σ s) Id Id] →
{s : String} → s.Pos → (pattern : ρ) → [String.Slice.Pattern.ToForwardSearcher pattern σ] → Option s.Pos | true |
CategoryTheory.ShortComplex.isLimitOfIsLimitπ | Mathlib.Algebra.Homology.ShortComplex.Limits | {J : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
{F : CategoryTheory.Functor J (CategoryTheory.ShortComplex C)} →
(c : CategoryTheory.Limits.... | true |
Set.biInter_finsetSigma_univ' | Mathlib.Data.Fintype.Sigma | ∀ {ι : Type u_1} {α : Type u_2} {κ : ι → Type u_3} [inst : (i : ι) → Fintype (κ i)] (s : Finset ι)
(f : (i : ι) → κ i → Set α), ⋂ i ∈ s, ⋂ j, f i j = ⋂ ij ∈ s.sigma fun x => Finset.univ, f ij.fst ij.snd | true |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.encodeExprWithEta.go._unsafe_rec | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | Array (Array Lean.Meta.RefinedDiscrTree.Key × Lean.Meta.RefinedDiscrTree.LazyEntry) →
Array (Array Lean.Meta.RefinedDiscrTree.Key) → Lean.MetaM (Array (Array Lean.Meta.RefinedDiscrTree.Key)) | false |
QuadraticModuleCat.instMonoidalCategoryStruct._proof_1 | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat.Monoidal | ∀ {R : Type u_1} [inst : CommRing R], SMulCommClass R R R | false |
LinearPMap.sSup | Mathlib.LinearAlgebra.LinearPMap | {R : Type u_1} →
[inst : Ring R] →
{E : Type u_2} →
[inst_1 : AddCommGroup E] →
[inst_2 : Module R E] →
{F : Type u_3} →
[inst_3 : AddCommGroup F] →
[inst_4 : Module R F] → (c : Set (E →ₗ.[R] F)) → DirectedOn (fun x1 x2 => x1 ≤ x2) c → E →ₗ.[R] F | true |
Std.Internal.IO.Async.UDP.Membership.rec | Std.Internal.Async.UDP | {motive : Std.Internal.IO.Async.UDP.Membership → Sort u} →
motive Std.Internal.IO.Async.UDP.Membership.leaveGroup →
motive Std.Internal.IO.Async.UDP.Membership.enterGroup → (t : Std.Internal.IO.Async.UDP.Membership) → motive t | false |
AddOpposite.one_le_op._simp_1 | Mathlib.Algebra.Order.Group.Opposite | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : PartialOrder α] {a : α}, (1 ≤ AddOpposite.op a) = (1 ≤ a) | false |
CategoryTheory.linearYoneda_map_app | Mathlib.CategoryTheory.Linear.Yoneda | ∀ (R : Type w) [inst : Ring R] (C : Type u) [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {X₁ X₂ : C} (f : X₁ ⟶ X₂) (Y : Cᵒᵖ),
((CategoryTheory.linearYoneda R C).map f).app Y =
ModuleCat.ofHom (CategoryTheory.Linear.rightComp R (Opposite... | true |
CommSemiRingCat.instConcreteCategoryRingHomCarrier | Mathlib.Algebra.Category.Ring.Basic | CategoryTheory.ConcreteCategory CommSemiRingCat fun R S => ↑R →+* ↑S | true |
Pi.instPNatPowAssoc | Mathlib.Algebra.Group.PNatPowAssoc | ∀ {ι : Type u_2} {α : ι → Type u_3} [inst : (i : ι) → Mul (α i)] [inst_1 : (i : ι) → Pow (α i) ℕ+]
[∀ (i : ι), PNatPowAssoc (α i)], PNatPowAssoc ((i : ι) → α i) | true |
AddGrpCat.addGroupObj._aux_1 | Mathlib.Algebra.Category.Grp.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_2, u_3} J] →
(F : CategoryTheory.Functor J AddGrpCat) → (j : J) → AddGroup ((F.comp (CategoryTheory.forget AddGrpCat)).obj j) | false |
Lean.KeyedDeclsAttribute.noConfusionType | Lean.KeyedDeclsAttribute | Sort u → {γ : Type} → Lean.KeyedDeclsAttribute γ → {γ' : Type} → Lean.KeyedDeclsAttribute γ' → Sort u | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.