name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Std.Data.ExtDHashMap.Lemmas.0.Std.ExtDHashMap.Const.alter_eq_empty_iff_erase_eq_empty._simp_1_2 | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u_1} {o : Option α}, (o = none) = (o.isNone = true) | false |
Lean.PrettyPrinter.Unexpander | Init.Prelude | Type | true |
lt_mul_iff_one_lt_right' | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : LT α] [MulLeftStrictMono α] [MulLeftReflectLT α] (a : α) {b : α},
a < a * b ↔ 1 < b | true |
Std.Net.instDecidableEqSocketAddressV6.decEq._proof_4 | Std.Net.Addr | ∀ (a : Std.Net.IPv6Addr) (a_1 : UInt16) (b : Std.Net.IPv6Addr) (b_1 : UInt16),
¬a = b → ¬{ addr := a, port := a_1 } = { addr := b, port := b_1 } | false |
Std.TreeSet.Raw.mk.injEq | Std.Data.TreeSet.Raw.Basic | ∀ {α : Type u} {cmp : autoParam (α → α → Ordering) Std.TreeSet.Raw._auto_1}
(inner inner_1 : Std.TreeMap.Raw α Unit cmp), ({ inner := inner } = { inner := inner_1 }) = (inner = inner_1) | true |
groupCohomology.cocyclesMap._proof_1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality | ∀ {k H : Type u_1} [inst : CommRing k] [inst_1 : Group H] {A : Rep.{u_1, u_1, u_1} k H} (n : ℕ),
(HomologicalComplex.sc (groupCohomology.inhomogeneousCochains A) n).HasHomology | false |
SimpleGraph.Preconnected | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | {V : Type u} → SimpleGraph V → Prop | true |
EReal.instPosMulReflectLT | Mathlib.Data.EReal.Inv | PosMulReflectLT EReal | true |
_private.Mathlib.Data.List.Nodup.0.List.nodup_iff_count_eq_one._proof_1_6 | Mathlib.Data.List.Nodup | ∀ {α : Type u_1} {l : List α} [inst : BEq α] (x : α)
(h : (List.count x l ≤ 1) = ¬(1 ≤ List.count x l → List.count x l = 1)) (left : List.count x l ≤ 1),
(List.findIdxs (fun x_1 => x_1 == x) l)[0] < l.length | false |
RatFunc.mk.congr_simp | Mathlib.FieldTheory.RatFunc.Defs | ∀ {K : Type u_1} [inst : CommRing K] [inst_1 : IsDomain K] (p p_1 : Polynomial K),
p = p_1 → ∀ (q q_1 : Polynomial K), q = q_1 → RatFunc.mk p q = RatFunc.mk p_1 q_1 | true |
DifferentiableOn.fun_sub | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f g : E → F}
{s : Set E}, DifferentiableOn 𝕜 f s → DifferentiableOn 𝕜 g s → DifferentiableOn 𝕜 (fun i => f i... | true |
_private.Std.Tactic.BVDecide.Normalize.BitVec.0.Std.Tactic.BVDecide.Normalize.BitVec.signExtend_elim._proof_1 | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {v w : ℕ}, v ≤ w → ¬w - v + v = w → False | false |
AffineEquiv.toAffineMap | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | {k : Type u_1} →
{P₁ : Type u_2} →
{P₂ : Type u_3} →
{V₁ : Type u_6} →
{V₂ : Type u_7} →
[inst : Ring k] →
[inst_1 : AddCommGroup V₁] →
[inst_2 : AddCommGroup V₂] →
[inst_3 : Module k V₁] →
[inst_4 : Module k V₂] →
... | true |
HopfAlgCat.MonoidalCategory.inducingFunctorData._proof_3 | Mathlib.Algebra.Category.HopfAlgCat.Monoidal | ∀ (R : Type u_1) [inst : CommRing R] {X₁ Y₁ X₂ Y₂ : HopfAlgCat R} (x : X₁ ⟶ Y₁) (x_1 : X₂ ⟶ Y₂),
(CategoryTheory.forget₂ (HopfAlgCat R) (BialgCat R)).map (CategoryTheory.MonoidalCategoryStruct.tensorHom x x_1) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Iso.refl
(CategoryTheory.MonoidalCa... | false |
HomologicalComplex.Hom.mk.noConfusion | Mathlib.Algebra.Homology.HomologicalComplex | {ι : Type u_1} →
{V : Type u} →
{inst : CategoryTheory.Category.{v, u} V} →
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms V} →
{c : ComplexShape ι} →
{A B : HomologicalComplex V c} →
{P : Sort u_2} →
{f : (i : ι) → A.X i ⟶ B.X i} →
{comm' :
... | false |
Std.ExtDTreeMap.Const.getThenInsertIfNew?_fst | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{k : α} {v : β}, (Std.ExtDTreeMap.Const.getThenInsertIfNew? t k v).1 = Std.ExtDTreeMap.Const.get? t k | true |
CategoryTheory.CoreSmallCategoryOfSet.functor._proof_1 | Mathlib.CategoryTheory.SmallRepresentatives | ∀ {Ω : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
(h : CategoryTheory.CoreSmallCategoryOfSet Ω C) (x : ↑h.smallCategoryOfSet.obj),
h.homEquiv (CategoryTheory.CategoryStruct.id x) = CategoryTheory.CategoryStruct.id (h.objEquiv x) | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Basic.0.SimplexCategory.δ_comp_σ_self._simp_1_1 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {n : ℕ} {a b : Fin n}, (a < b) = (↑a < ↑b) | false |
_private.Mathlib.Data.WSeq.Basic.0.Stream'.WSeq.destruct.match_1.eq_1 | Mathlib.Data.WSeq.Basic | ∀ {α : Type u_1} (motive : Option (Stream'.Seq1 (Option α)) → Sort u_2) (h_1 : Unit → motive none)
(h_2 : (s' : Stream'.Seq (Option α)) → motive (some (none, s')))
(h_3 : (a : α) → (s' : Stream'.Seq (Option α)) → motive (some (some a, s'))),
(match none with
| none => h_1 ()
| some (none, s') => h_2 s'
... | true |
MulDistribMulAction | Mathlib.Algebra.Group.Action.Defs | (M : Type u_9) → (N : Type u_10) → [Monoid M] → [Monoid N] → Type (max u_10 u_9) | true |
cfcₙL.congr_simp | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Integral | ∀ {R : Type u_1} {A : Type u_2} {p p_1 : A → Prop} (e_p : p = p_1) [inst : CommSemiring R] [inst_1 : Nontrivial R]
[inst_2 : StarRing R] [inst_3 : MetricSpace R] [inst_4 : IsTopologicalSemiring R] [inst_5 : ContinuousStar R]
[inst_6 : NonUnitalRing A] [inst_7 : StarRing A] [inst_8 : TopologicalSpace A] [inst_9 : Mo... | true |
_private.Mathlib.Algebra.Lie.Ideal.0.LieHom.isIdealMorphism_iff._simp_1_6 | Mathlib.Algebra.Lie.Ideal | ∀ {R : Type u} (L : Type v) {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (p : Submodule R M), (∃ N, ↑N = p) = ∀ (x : L), ∀ m ∈ p, ⁅x, m⁆ ∈ p | false |
CategoryTheory.InducedWideCategory.Hom._sizeOf_inst | Mathlib.CategoryTheory.Widesubcategory | {C : Type u₁} →
{D : Type u₂} →
{inst : CategoryTheory.Category.{v₁, u₂} D} →
{F : C → D} →
{P : CategoryTheory.MorphismProperty D} →
{inst_1 : P.IsMultiplicative} →
(X Y : CategoryTheory.InducedWideCategory D F P) →
[SizeOf C] → [SizeOf D] → [⦃X Y : D⦄ → (x : X ⟶... | false |
Lean.Compiler.LCNF.Simp.CtorInfo | Lean.Compiler.LCNF.Simp.DiscrM | Type | true |
Lean.Elab.Term.exceptionToSorry | Lean.Elab.Term.TermElabM | Lean.Exception → Option Lean.Expr → Lean.Elab.TermElabM Lean.Expr | true |
FirstOrder.Language.Term.func | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} → {α : Type u'} → {l : ℕ} → L.Functions l → (Fin l → L.Term α) → L.Term α | true |
Std.DHashMap.Internal.Raw₀.get_insertMany_list_of_contains_eq_false | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α]
[inst_2 : LawfulBEq α] (h : (↑m).WF) {l : List ((a : α) × β a)} {k : α}
(contains : (List.map Sigma.fst l).contains k = false) {h' : (↑(m.insertMany l)).contains k = true},
(↑(m.insertMany l)).get k h' = m.ge... | true |
LinearMap.iterateMapComap_le_succ | Mathlib.Algebra.Module.Submodule.IterateMapComap | ∀ {R : Type u_1} {N : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid N] [inst_2 : Module R N]
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] (f i : N →ₗ[R] M) (K : Submodule R N),
Submodule.map f K ≤ Submodule.map i K → ∀ (n : ℕ), f.iterateMapComap i n K ≤ f.iterateMapComap i (n + 1) K | true |
MonoidAlgebra.unique | Mathlib.Algebra.MonoidAlgebra.Defs | {R : Type u_1} → {M : Type u_4} → [inst : Semiring R] → [Subsingleton R] → Unique (MonoidAlgebra R M) | true |
Lean.Lsp.instToJsonLeanModule | Lean.Data.Lsp.Extra | Lean.ToJson Lean.Lsp.LeanModule | true |
HomologicalComplex.Acyclic | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{ι : Type u_2} → {c : ComplexShape ι} → HomologicalComplex C c → Prop | true |
iInf₂_eq_top | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} {κ : ι → Sort u_6} [inst : CompleteLattice α] {f : (i : ι) → κ i → α},
⨅ i, ⨅ j, f i j = ⊤ ↔ ∀ (i : ι) (j : κ i), f i j = ⊤ | true |
HasFPowerSeriesAt.tendsto_partialSum_prod_of_comp | Mathlib.Analysis.Analytic.Inverse | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type u_4}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f : E → G} {q : FormalMultilinearSer... | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.id_actionHomLeft_assoc | 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) (d : D) {Z : D}
(h : CategoryTheory.MonoidalCategory.MonoidalRightActi... | true |
Lean.Parser.termParser.parenthesizer | Lean.Parser.Extra | optParam ℕ 0 → Lean.PrettyPrinter.Parenthesizer | true |
_private.Mathlib.Analysis.Analytic.Order.0.AnalyticOnNhd.isClopen_setOf_analyticOrderAt_eq_top._proof_1_2 | Mathlib.Analysis.Analytic.Order | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E] {U : Set 𝕜}
{f : 𝕜 → E} (z : ↑U) (t' : Set 𝕜),
(∀ y ∈ t', f y = 0) → IsOpen t' → Subtype.val ⁻¹' t' ⊆ {x | ∃ t, (∀ y ∈ t, f y = 0) ∧ IsOpen t ∧ ↑x ∈ t} | false |
_private.Mathlib.Data.Finset.Union.0.Finset.coe_disjiUnion._simp_1_1 | Mathlib.Data.Finset.Union | ∀ {α : Type u} {a b : Set α}, (a = b) = ∀ (x : α), x ∈ a ↔ x ∈ b | false |
_private.Batteries.Tactic.SqueezeScope.0.Batteries.Tactic._aux_Batteries_Tactic_SqueezeScope___elabRules__private_Batteries_Tactic_SqueezeScope_0_Batteries_Tactic_squeezeScopeIn_1._sparseCasesOn_5 | Batteries.Tactic.SqueezeScope | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Lean.Meta.trySubstVar | Lean.Meta.Tactic.Subst | Lean.MVarId → Lean.FVarId → Lean.MetaM Lean.MVarId | true |
hasFDerivAt_ringInverse | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {R : Type u_5} [inst_1 : NormedRing R] [HasSummableGeomSeries R]
[inst_3 : NormedAlgebra 𝕜 R] (x : Rˣ),
HasFDerivAt Ring.inverse (-((ContinuousLinearMap.mulLeftRight 𝕜 R) ↑x⁻¹) ↑x⁻¹) ↑x | true |
instT1SpaceCofiniteTopology | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1}, T1Space (CofiniteTopology X) | true |
Lean.Server.RpcProcedure.noConfusionType | Lean.Server.Rpc.RequestHandling | Sort u → Lean.Server.RpcProcedure → Lean.Server.RpcProcedure → Sort u | false |
PiTensorProduct.toDualContinuousMultilinearMap._proof_6 | Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] (F : Type u_2) [inst_1 : SeminormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F], SMulCommClass 𝕜 𝕜 F | false |
CategoryTheory.Functor.LaxMonoidal.mk.congr_simp | Mathlib.CategoryTheory.Monoidal.Braided.Transport | ∀ {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 : CategoryTheory.Functor C D}
(ε ε_1 :
CategoryTheory.MonoidalCategoryStruct.tensorUnit D ⟶ F.obj... | true |
CategoryTheory.ProjectiveResolution.extMk._proof_1 | Mathlib.CategoryTheory.Abelian.Projective.Ext | ∀ {n : ℕ}, -↑n + ↑n = 0 | false |
AlgebraicGeometry.Scheme.IsLocallyDirected.ι_eq_ι_iff | Mathlib.AlgebraicGeometry.Gluing | ∀ {J : Type w} [inst : CategoryTheory.Category.{v, w} J] (F : CategoryTheory.Functor J AlgebraicGeometry.Scheme)
[inst_1 : ∀ {i j : J} (f : i ⟶ j), AlgebraicGeometry.IsOpenImmersion (F.map f)]
[inst_2 : (F.comp AlgebraicGeometry.Scheme.forget).IsLocallyDirected] [inst_3 : Quiver.IsThin J]
[inst_4 : Small.{u, w} J... | true |
AddHomClass.map_add | Mathlib.Algebra.Group.Hom.Defs | ∀ {F : Type u_10} {M : outParam (Type u_11)} {N : outParam (Type u_12)} {inst : Add M} {inst_1 : Add N}
{inst_2 : FunLike F M N} [self : AddHomClass F M N] (f : F) (x y : M), f (x + y) = f x + f y | true |
_private.Mathlib.Tactic.Widget.Conv.0.Mathlib.Tactic.Conv.Path.ofSubExprPosArray.appT._sparseCasesOn_1 | Mathlib.Tactic.Widget.Conv | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.Pseudofunctor.Grothendieck.recOn | Mathlib.CategoryTheory.Bicategory.Grothendieck | {𝒮 : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮) CategoryTheory.Cat} →
{motive : F.Grothendieck → Sort u} →
(t : F.Grothendieck) →
((base : 𝒮) → (fiber : ↑(F.obj { as := base })) → motive { base := base, ... | false |
LinearMap.sq_singularValues_fin | Mathlib.Analysis.InnerProductSpace.SingularValues | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : FiniteDimensional 𝕜 E] {F : Type u_3} [inst_4 : NormedAddCommGroup F] [inst_5 : InnerProductSpace 𝕜 F]
[inst_6 : FiniteDimensional 𝕜 F] (T : E →ₗ[𝕜] F) {n : ℕ} (hn : Module.finrank 𝕜 ... | true |
SimpleGraph.egirth_eq_top._simp_1 | Mathlib.Combinatorics.SimpleGraph.Girth | ∀ {α : Type u_1} {G : SimpleGraph α}, (G.egirth = ⊤) = G.IsAcyclic | false |
CategoryTheory.MorphismProperty.FunctorialFactorizationData.functorCategory._proof_3 | Mathlib.CategoryTheory.MorphismProperty.Factorization | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {W₁ W₂ : CategoryTheory.MorphismProperty C}
(data : W₁.FunctorialFactorizationData W₂) (J : Type u_1) [inst_1 : CategoryTheory.Category.{u_4, u_1} J]
(x : CategoryTheory.Arrow (CategoryTheory.Functor J C)) (x_1 : J),
W₂ (data.p.app (CategoryTheory.Arr... | false |
Int.toNat_add_nat | Init.Data.Int.Order | ∀ {a : ℤ}, 0 ≤ a → ∀ (n : ℕ), (a + ↑n).toNat = a.toNat + n | true |
BoundedContinuousFunction.mkOfCompact._proof_1 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u_2} {β : Type u_1} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β] [CompactSpace α]
(f : C(α, β)), ∃ C, ∀ (x y : α), dist (f.toFun x) (f.toFun y) ≤ C | false |
ClosedSubgroup.ext_iff | Mathlib.Topology.Algebra.Group.ClosedSubgroup | ∀ {G : Type u} {inst : Group G} {inst_1 : TopologicalSpace G} {x y : ClosedSubgroup G},
x = y ↔ (↑x).carrier = (↑y).carrier | true |
Complex.addGroupWithOne._proof_7 | Mathlib.Data.Complex.Basic | ∀ (n : ℕ) (a : ℂ), SubNegMonoid.zsmul (↑n.succ) a = SubNegMonoid.zsmul (↑n) a + a | false |
Finsupp.comapDomain_apply | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : Zero M] (f : α → β) (l : β →₀ M)
(hf : Set.InjOn f (f ⁻¹' ↑l.support)) (a : α), (Finsupp.comapDomain f l hf) a = l (f a) | true |
Lean.Server.ReferencedObject.noConfusion | Lean.Server.Rpc.Basic | {P : Sort u} → {t t' : Lean.Server.ReferencedObject} → t = t' → Lean.Server.ReferencedObject.noConfusionType P t t' | false |
AList.lookupFinsupp_apply | Mathlib.Data.Finsupp.AList | ∀ {α : Type u_1} {M : Type u_2} [inst : Zero M] [inst_1 : DecidableEq α] (l : AList fun _x => M) (a : α),
l.lookupFinsupp a = (AList.lookup a l).getD 0 | true |
Prod.instCompleteAtomicBooleanAlgebra._proof_11 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteAtomicBooleanAlgebra α] [inst_1 : CompleteAtomicBooleanAlgebra β]
(x y : α × β), x \ y = x ⊓ yᶜ | false |
Mathlib.Tactic.BicategoryLike.MkEvalComp.noConfusion | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {P : Sort u} →
{m : Type → Type} →
{t : Mathlib.Tactic.BicategoryLike.MkEvalComp m} →
{m' : Type → Type} →
{t' : Mathlib.Tactic.BicategoryLike.MkEvalComp m'} →
m = m' → t ≍ t' → Mathlib.Tactic.BicategoryLike.MkEvalComp.noConfusionType P t t' | false |
_private.Mathlib.RingTheory.DedekindDomain.Different.0.FractionalIdeal._aux_Mathlib_RingTheory_DedekindDomain_Different___unexpand_Submodule_traceDual_1 | Mathlib.RingTheory.DedekindDomain.Different | Lean.PrettyPrinter.Unexpander | false |
_private.Mathlib.Data.Multiset.Fintype.0.Multiset.map_fst_le_of_subset_toEnumFinset._simp_1_1 | Mathlib.Data.Multiset.Fintype | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Multiset α}, (s ≤ t) = ∀ (a : α), Multiset.count a s ≤ Multiset.count a t | false |
Subsemigroup.instInfSet.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} [inst : Mul M],
Subsemigroup.instInfSet = { sInf := fun s => { carrier := ⋂ t ∈ s, ↑t, mul_mem' := ⋯ } } | true |
instHasDistribNegLex | Mathlib.Algebra.Order.Ring.Synonym | {R : Type u_1} → [inst : Mul R] → [h : HasDistribNeg R] → HasDistribNeg (Lex R) | true |
Std.TreeMap.Raw.WF.filter | Std.Data.TreeMap.Raw.WF | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
{f : α → β → Bool}, t.WF → (Std.TreeMap.Raw.filter f t).WF | true |
Associates.dvd_of_mem_factors' | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] {a : α} {p : Associates α}
{hp : Irreducible p} {hz : a ≠ 0}, ⟨p, hp⟩ ∈ Associates.factors' a → p ∣ Associates.mk a | true |
CategoryTheory.Limits.PullbackCone.eta._proof_2 | 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),
t.fst =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Iso.refl t.pt).hom
(CategoryTheory.Limits.PullbackCone.mk t.fst t.snd ⋯).fst | false |
AlgebraicGeometry.UniversallyOpen.instRespectsIsoScheme | Mathlib.AlgebraicGeometry.Morphisms.UniversallyOpen | CategoryTheory.MorphismProperty.RespectsIso @AlgebraicGeometry.UniversallyOpen | true |
CategoryTheory.Functor.asEquivalence | Mathlib.CategoryTheory.Equivalence | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] → (F : CategoryTheory.Functor C D) → [F.IsEquivalence] → C ≌ D | true |
List.Chain | Batteries.Data.List.Basic | {α : Type u_1} → (α → α → Prop) → α → List α → Prop | true |
FreeAlgebra.Pre.instInhabited | Mathlib.Algebra.FreeAlgebra | (R : Type u_1) → (X : Type u_2) → [CommSemiring R] → Inhabited (FreeAlgebra.Pre R X) | true |
NonUnitalStarSubalgebra.val_inclusion | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : StarRing A]
[inst_3 : Module R A] {S T : NonUnitalStarSubalgebra R A} (h : S ≤ T) (s : ↥S),
↑((NonUnitalStarSubalgebra.inclusion h) s) = ↑s | true |
CategoryTheory.ProjectiveResolution.liftFOne | Mathlib.CategoryTheory.Abelian.Projective.Resolution | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
{Y Z : C} →
(Y ⟶ Z) →
(P : CategoryTheory.ProjectiveResolution Y) →
(Q : CategoryTheory.ProjectiveResolution Z) → P.complex.X 1 ⟶ Q.complex.X 1 | true |
norm_algebraMap_nnreal | Mathlib.Analysis.Normed.Module.Basic | ∀ (𝕜' : Type u_2) [inst : SeminormedRing 𝕜'] [NormOneClass 𝕜'] [inst_2 : NormedAlgebra ℝ 𝕜'] (x : NNReal),
‖(algebraMap NNReal 𝕜') x‖ = ↑x | true |
_private.Lean.Elab.Extra.0.Lean.Elab.Term.Op.hasHeterogeneousDefaultInstances | Lean.Elab.Extra | Lean.Expr → Lean.Expr → Bool → Lean.MetaM Bool | true |
ContinuousAffineEquiv.constVAdd._proof_2 | Mathlib.Topology.Algebra.ContinuousAffineEquiv | ∀ (P₁ : Type u_1) {V₁ : Type u_2} [inst : AddCommGroup V₁] [inst_1 : AddTorsor V₁ P₁] [inst_2 : TopologicalSpace P₁]
[ContinuousConstVAdd V₁ P₁] (v : V₁), Continuous fun x => -v +ᵥ x | false |
Std.Time.TimeZone.ZoneRules.mk | Std.Time.Zoned.ZoneRules | Std.Time.TimeZone.LocalTimeType → Array Std.Time.TimeZone.Transition → Std.Time.TimeZone.ZoneRules | true |
FintypeCat.uSwitch._proof_1 | Mathlib.CategoryTheory.FintypeCat | ∀ (X : FintypeCat), Finite (ULift.{u_1, 0} (Fin (Fintype.card X.obj))) | false |
ContinuousOn.integrableOn_uIcc | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {E : Type u_6} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : NormedAddCommGroup E]
{μ : MeasureTheory.Measure X} [OpensMeasurableSpace X] {f : X → E} {a b : X}
[MeasureTheory.IsFiniteMeasureOnCompacts μ] [inst_5 : LinearOrder X] [CompactIccSpace X] [T2Space X],
ContinuousOn f... | true |
MeasureTheory.Measure.IsHaarMeasure.recOn | Mathlib.MeasureTheory.Group.Measure | {G : Type u_3} →
[inst : Group G] →
[inst_1 : TopologicalSpace G] →
[inst_2 : MeasurableSpace G] →
{μ : MeasureTheory.Measure G} →
{motive : μ.IsHaarMeasure → Sort u} →
(t : μ.IsHaarMeasure) →
([toIsFiniteMeasureOnCompacts : MeasureTheory.IsFiniteMeasureOnCompacts... | false |
LLVM.DLLStorageClass.import | Lean.Compiler.IR.LLVMBindings | LLVM.DLLStorageClass | true |
CategoryTheory.Limits.colimitFlipCompColimIsoColimitCompColim | Mathlib.CategoryTheory.Limits.Fubini | {J : Type u_1} →
{K : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} K] →
{C : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] →
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) →
[in... | true |
VAddCon.instVAddQuotient | Mathlib.Algebra.Module.Congruence.Defs | {S : Type u_2} → (M : Type u_3) → [inst : VAdd S M] → (c : VAddCon S M) → VAdd S (VAddCon.Quotient M c) | true |
CategoryTheory.Sieve.sieveOfUliftSubfunctor._proof_3 | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C}
{R : CategoryTheory.Functor Cᵒᵖ (Type (max u_3 u_1))} (f : R ⟶ CategoryTheory.uliftYoneda.{u_3, u_1, u_2}.obj X)
{Y Z : C} {f_1 : Y ⟶ X},
(∃ t, f.app (Opposite.op Y) t = { down := f_1 }) →
∀ (g : Z ⟶ Y), ∃ t, f.app (Opposite.op Z) t = { do... | false |
CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prodLift._proof_2 | Mathlib.CategoryTheory.Localization.Prod | ∀ {C₁ : Type u_3} {C₂ : Type u_2} [inst : CategoryTheory.Category.{u_6, u_3} C₁]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {E : Type u_5} [inst_2 : CategoryTheory.Category.{u_4, u_5} E]
(F : CategoryTheory.Functor (C₁ × C₂)... | false |
Nat.reduceGcd | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | Lean.Meta.Simp.DSimproc | true |
BitVec.msb_sshiftRight | Init.Data.BitVec.Lemmas | ∀ {w n : ℕ} {x : BitVec w}, (x.sshiftRight n).msb = x.msb | true |
lt_csSup_of_lt | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {s : Set α} {a b : α}, BddAbove s → a ∈ s → b < a → b < sSup s | true |
_private.Mathlib.NumberTheory.LucasLehmer.0.LucasLehmer.ω_pow_formula._simp_1_1 | Mathlib.NumberTheory.LucasLehmer | ∀ (a : ℤ) (b : ℕ), (↑a = 0) = (↑b ∣ a) | false |
instContinuousConstSMulForall | Mathlib.Topology.Algebra.ConstMulAction | ∀ {M : Type u_1} {ι : Type u_4} {γ : ι → Type u_5} [inst : (i : ι) → TopologicalSpace (γ i)]
[inst_1 : (i : ι) → SMul M (γ i)] [∀ (i : ι), ContinuousConstSMul M (γ i)], ContinuousConstSMul M ((i : ι) → γ i) | true |
QuadraticMap.Isometry.tmul._proof_1 | Mathlib.LinearAlgebra.QuadraticForm.TensorProduct.Isometries | (1 + 1).AtLeastTwo | false |
Std.DTreeMap.Internal.Impl.Const.getEntryGT._unsafe_rec | Std.Data.DTreeMap.Internal.Queries | {α : Type u} →
{β : Type v} →
[inst : Ord α] →
[Std.TransOrd α] →
(k : α) →
(t : Std.DTreeMap.Internal.Impl α fun x => β) → t.Ordered → (∃ a ∈ t, compare a k = Ordering.gt) → α × β | false |
Monotone.pairwise_disjoint_on_Ico_pred | Mathlib.Order.SuccPred.IntervalSucc | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : PredOrder α] [inst_2 : Preorder β] {f : α → β},
Monotone f → Pairwise (Function.onFun Disjoint fun n => Set.Ico (f (Order.pred n)) (f n)) | true |
Zsqrtd.re_neg | Mathlib.NumberTheory.Zsqrtd.Basic | ∀ {d : ℤ} (z : ℤ√d), (-z).re = -z.re | true |
_private.Mathlib.Topology.IndicatorConstPointwise.0.tendsto_ite._simp_1_8 | Mathlib.Topology.IndicatorConstPointwise | ∀ {α : Type u_1} {f : Filter α} {a : α}, (f ≤ pure a) = ({a} ∈ f) | false |
CategoryTheory.MonoidalClosed.closed | Mathlib.CategoryTheory.Monoidal.Closed.Basic | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} →
[self : CategoryTheory.MonoidalClosed C] → (X : C) → CategoryTheory.Closed X | true |
MonadWithReaderOf.recOn | Init.Prelude | {ρ : Type u} →
{m : Type u → Type v} →
{motive : MonadWithReaderOf ρ m → Sort u_1} →
(t : MonadWithReaderOf ρ m) →
((withReader : {α : Type u} → (ρ → ρ) → m α → m α) → motive { withReader := withReader }) → motive t | false |
CompRel.of_compRel_of_antisymmRel | Mathlib.Order.Comparable | ∀ {α : Type u_1} {a b c : α} [inst : Preorder α],
CompRel (fun x1 x2 => x1 ≤ x2) a b → AntisymmRel (fun x1 x2 => x1 ≤ x2) b c → CompRel (fun x1 x2 => x1 ≤ x2) a c | true |
ProofWidgets.MarkdownDisplay.instToJsonProps.toJson | ProofWidgets.Component.Basic | ProofWidgets.MarkdownDisplay.Props → Lean.Json | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.