name string | module string | deps list | allowCompletion bool |
|---|---|---|---|
AddOpposite.instNonUnitalCommRing._proof_1 | Mathlib.Algebra.Ring.Opposite | [
"HMul.hMul",
"NonUnitalCommSemiring.mul_comm",
"AddOpposite",
"NonUnitalNonAssocSemiring.toMul",
"NonUnitalSemiring.toNonUnitalNonAssocSemiring",
"NonUnitalCommRing",
"NonUnitalCommSemiring.toNonUnitalSemiring",
"NonUnitalCommRing.toNonUnitalCommSemiring",
"Eq",
"AddOpposite.instNonUnitalCommSemir... | false |
_private.Init.Data.String.Termination.0.String.Slice.Pos.wellFounded_lt._simp_1_2 | Init.Data.String.Termination | [
"String.instLTRaw",
"String.Pos.Raw.lt_iff",
"String.Pos.Raw",
"Nat",
"LT.lt",
"propext",
"instLTNat",
"String.Pos.Raw.byteIdx",
"Eq"
] | false |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Search.0.Lean.Meta.Grind.Arith.Linear.assignElimVars.go.match_1 | Lean.Meta.Tactic.Grind.Arith.Linear.Search | [
"_private.Lean.Meta.Tactic.Grind.Arith.Linear.Search.0.Lean.Meta.Grind.Arith.Linear.getBestLower?._sparseCasesOn_1",
"Option.ctorIdx",
"Lean.Meta.Grind.Arith.Linear.EqCnstr",
"Option.some",
"Nat.hasNotBit",
"Option"
] | false |
Real.binEntropy_lt_log_two | Mathlib.Analysis.SpecialFunctions.BinaryEntropy | [
"IsRightCancelAdd.addRightStrictMono_of_addRightMono",
"Iff.mpr",
"sub_pos",
"AddGroup.toSubtractionMonoid",
"NonUnitalNonAssocCommRing.toNonUnitalNonAssocCommSemiring",
"Real.instIsOrderedRing",
"Mathlib.Tactic.Ring.Common.neg_zero",
"Eq.mpr",
"lt_or_gt_of_ne",
"GroupWithZero.toMonoidWithZero",
... | true |
Finmap.mem_replace | Mathlib.Data.Finmap | [
"congrArg",
"Finmap.instMembership",
"Membership.mem",
"Finmap.replace",
"iff_self",
"AList.replace",
"Iff",
"Finmap.induction_on",
"Finmap.mem_toFinmap._simp_1",
"congr",
"AList",
"True",
"of_eq_true",
"congrFun'",
"Finmap.replace_toFinmap",
"AList.instMembership",
"AList.toFinmap",... | true |
MulEquiv.map_inv | Mathlib.Algebra.Group.Equiv.Defs | [
"DivInvMonoid.toInv",
"MulEquiv.instEquivLike",
"map_inv",
"Monoid.toMulOneClass",
"MulEquiv.instMulEquivClass",
"Group",
"DivisionMonoid",
"MulOne.toMul",
"DivInvMonoid.toMonoid",
"DivisionMonoid.toDivInvMonoid",
"Group.toDivInvMonoid",
"MulOneClass.toMulOne",
"Inv.inv",
"MulEquivClass.in... | true |
CochainComplex.HomComplex.Cochain.shiftAddHom._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | [
"HomologicalComplex.instCategory",
"CochainComplex.HomComplex.instAddCommGroupCochain",
"CochainComplex.HomComplex.Cochain.shift_add",
"CochainComplex.HomComplex.Cochain.shift",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"AddGroupWithOne.toAddMonoidWithOne",
"AddRightCan... | false |
Submonoid.mem_map_of_mem | Mathlib.Algebra.Group.Submonoid.Operations | [
"Membership.mem",
"Submonoid.map",
"MulOneClass.toMulOne",
"SetLike.coe",
"Set.mem_image_of_mem",
"MonoidHomClass",
"Submonoid.instSetLike",
"MulOneClass",
"DFunLike.coe",
"SetLike.instMembership",
"Submonoid",
"FunLike"
] | true |
groupHomology.opcyclesIso₀._proof_4 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | [
"CommRing",
"groupHomology.cyclesIso₀._proof_3",
"Nat.instOne",
"ModuleCat",
"CommSemiring.toSemiring",
"CategoryTheory.ShortComplex.HasHomology",
"AddRightCancelSemigroup.toAddSemigroup",
"AddCancelMonoid.toAddRightCancelMonoid",
"Group",
"Nat.instAddCancelCommMonoid",
"DivInvMonoid.toMonoid",
... | false |
_private.Mathlib.Tactic.Linarith.Frontend.0.Mathlib.Tactic.Linarith.linarithUsedHyps.match_7 | Mathlib.Tactic.Linarith.Frontend | [
"Lean.MVarId",
"Lean.Expr",
"Prod.mk",
"Prod",
"Prod.casesOn",
"Option"
] | false |
Lean.Lsp.WorkspaceClientCapabilities.mk.noConfusion | Lean.Data.Lsp.Capabilities | [
"Lean.Lsp.WorkspaceClientCapabilities.noConfusion",
"id",
"Lean.Lsp.WorkspaceEditClientCapabilities",
"Bool",
"Eq",
"Lean.Lsp.WorkspaceClientCapabilities.mk",
"Lean.Lsp.WorkspaceClientCapabilities",
"Option"
] | false |
CategoryTheory.Functor.rightAdjointObjIsDefined_of_adjunction | Mathlib.CategoryTheory.Adjunction.PartialAdjoint | [
"CategoryTheory.Functor.op",
"CategoryTheory.Functor",
"Opposite",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.Adjunction.representableBy",
"CategoryTheory.yoneda",
"CategoryTheory.Functor.RepresentableBy.isRepresentable",
"CategoryTheory.types",
"CategoryTheo... | true |
Lean.Parser.Tactic._aux_Std_Tactic_Do_Syntax___macroRules_Lean_Parser_Tactic_mreplaceError_1 | Std.Tactic.Do.Syntax | [
"Lean.TSyntax",
"instMonadExceptOfMonadExceptOf",
"MonadExcept.throw",
"Lean.Syntax.isOfKind",
"EStateM.instMonad",
"Lean.Macro.Exception",
"Lean.Syntax",
"Lean.Macro.throwError",
"Lean.TSyntax.raw",
"instDecidableEqBool",
"instOfNatNat",
"Lean.MacroM",
"Lean.Macro.Context",
"List.cons",
... | false |
Bool.atLeastTwo_true_left | Init.Data.BitVec.Bitblast | [
"Bool.or_true",
"Bool.and_false",
"congrArg",
"Bool.and_true",
"Bool.and",
"Bool.or_self",
"Bool.and_self",
"Bool.true",
"Bool.casesOn",
"congr",
"True",
"eq_self",
"Bool",
"of_eq_true",
"Eq.ndrec",
"Bool.or",
"Eq.refl",
"Bool.atLeastTwo",
"Eq.symm",
"Bool.false",
"Eq",
"Bo... | true |
_private.Mathlib.Probability.Kernel.Disintegration.CondCDF.0.ProbabilityTheory.preCDF_le_one._simp_1_1 | Mathlib.Probability.Kernel.Disintegration.CondCDF | [
"MeasurableSet",
"Set.univ",
"MeasurableSpace",
"True",
"eq_true",
"Eq",
"MeasurableSet.univ"
] | false |
Finset.nsmul_empty | Mathlib.Algebra.Group.Pointwise.Finset.Basic | [
"Finset.add_empty",
"instHSMul",
"AddMonoid.toAddSemigroup",
"congrArg",
"Finset",
"AddMonoid.toAddZeroClass",
"AddMonoid.toNSMul",
"AddZeroClass.toAddZero",
"Ne",
"instOfNatNat",
"Finset.instEmptyCollection",
"AddZero.toZero",
"instHAdd",
"AddSemigroup.toAdd",
"HAdd.hAdd",
"Nat",
"T... | true |
MonoidWithZeroHom.ValueGroup₀.restrict₀_eq_zero_iff | Mathlib.Algebra.GroupWithZero.Range | [
"GroupWithZero.toMonoidWithZero",
"False",
"Classical.not_not._simp_1",
"Monoid.toMulOneClass",
"congrArg",
"GroupWithZero",
"MonoidWithZeroHom.funLike",
"Membership.mem",
"Units",
"MonoidWithZeroHom.ValueGroup₀.restrict₀._proof_2",
"Classical.decPred",
"WithZero.instMulZeroOneClass",
"Subty... | true |
Std.Iter.Equiv.trans | Std.Data.Iterators.Lemmas.Equivalence.Basic | [
"Std.Iter.toIterM",
"Id",
"Std.BundledIterM.ofIterM",
"Std.Iterator",
"Std.Iter",
"Std.Iter.Equiv",
"Id.instMonad",
"Std.BundledIterM.Equiv.trans",
"Id.instLawfulMonad"
] | true |
ENNReal.instDivInvMonoid._proof_4 | Mathlib.Data.ENNReal.Basic | [
"Mul.mk",
"Semigroup.toMul",
"One.mk",
"CommSemiring.toSemiring",
"Int",
"ENNReal.instCommSemiring",
"npowRec",
"Nat.cast",
"One.one",
"Inv.inv",
"Inv.mk",
"Mul.mul",
"Nat",
"ENNReal",
"Semiring.toMonoid",
"zpowRec",
"Monoid.toSemigroup",
"Eq.refl",
"ENNReal.instInv",
"Monoid.t... | false |
Lean.Meta.DefaultInstances.mk.inj | Lean.Meta.Instances | [
"Lean.NameMap",
"Lean.Meta.DefaultInstances.mk",
"Lean.Meta.DefaultInstances.mk.noConfusion",
"List",
"And",
"Nat",
"And.intro",
"Lean.Meta.DefaultInstances",
"Lean.Name",
"Lean.Meta.PrioritySet",
"Prod",
"Eq"
] | true |
CategoryTheory.GradedObject.mapBifunctorBifunctor₂₃Desc.congr_simp | Mathlib.CategoryTheory.GradedObject.Trifunctor | [
"CategoryTheory.GradedObject.mapBifunctorBifunctor₂₃Desc",
"CategoryTheory.Functor",
"CategoryTheory.GradedObject.HasMap",
"CategoryTheory.GradedObject.BifunctorComp₂₃IndexData.p",
"CategoryTheory.GradedObject.mapBifunctorMapObj",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory... | true |
PadicInt.residueField._proof_5 | Mathlib.NumberTheory.Padics.RingHoms | [
"Nat.Prime",
"ZMod.commRing",
"PadicInt",
"CommSemiring.toSemiring",
"RingHom",
"Fact",
"PadicInt.instCommRing",
"CommRing.toNonAssocCommRing",
"ZMod",
"ZMod.ringHom_surjective",
"CommRing.toCommSemiring",
"RingHom.instFunLike",
"Nat",
"PadicInt.toZMod",
"Semiring.toNonAssocSemiring",
... | false |
TwoSidedIdeal.orderIsoIdeal._proof_4 | Mathlib.RingTheory.TwoSidedIdeal.Operations | [
"SetLike.mem_coe._simp_1",
"CommRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"CommRing.toNonUnitalCommRing",
"congrArg",
"CommSemiring.toSemiring",
"TwoSidedIdeal",
"TwoSidedIdeal.coe_mk'",
"Membership.mem",
"Ideal.add_mem",
"Submodule.neg_mem",
"imp_self._sim... | false |
Lean.Grind.CommRing.Poly.mulConst | Init.Grind.Ring.CommSolver | [
"cond",
"Lean.Grind.CommRing.Poly",
"Int.instDecidableEq",
"Int",
"instBEqOfDecidableEq",
"BEq.beq",
"instOfNat",
"Lean.Grind.CommRing.Poly.mulConst.go",
"OfNat.ofNat",
"Lean.Grind.CommRing.Poly.num"
] | true |
Manifold.IsSubmersionAtOfComplement.prodMap | Mathlib.Geometry.Manifold.Submersion | [
"Set.instSProd",
"Eq.mpr",
"Prod.normedSpace",
"_private.Mathlib.Geometry.Manifold.Submersion.0.Manifold.IsSubmersionAtOfComplement.prodMap.match_1_1",
"Prod.normedAddCommGroup",
"NormedSpace",
"Set.eqOn_prod_iff",
"SProd.sprod",
"congrArg",
"PartialEquiv.prod",
"AddCommGroup.toAddCommMonoid",
... | true |
AddMagmaCat.comp_apply | Mathlib.Algebra.Category.Semigrp.Basic | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.ConcreteCategory.hom",
"AddHom",
"AddMagmaCat.Hom.hom",
"AddMagmaCat.str",
"AddHom.funLike",
"AddMagmaCat.carrier",
"AddMagmaCat",
"eq_self",
"CategoryTheory.CategoryStruct.comp",
"of_eq_true",
"CategoryTheory.Category.t... | true |
PosNum.commMonoid._proof_1 | Mathlib.Data.Num.Lemmas | [
"Eq.mpr",
"castPosNum",
"HMul.hMul",
"Nat.instOne",
"CommSemiring.toNonUnitalCommSemiring",
"congrArg",
"id",
"PosNum.to_nat_inj",
"CommMagma.toMul",
"instMulNat",
"NonUnitalCommSemiring.toNonUnitalNonAssocCommSemiring",
"mul_left_comm",
"PosNum.mul_to_nat",
"Nat",
"NonUnitalNonAssocComm... | false |
Padic.mk_eq | Mathlib.NumberTheory.Padics.PadicNumbers | [
"padicNorm.instIsAbsoluteValueRat",
"NormedCommRing.toNormedRing",
"Padic.mk",
"Nat.Prime",
"NormedRing.toRing",
"Rat",
"Rat.linearOrder",
"Fact",
"Quotient.eq'",
"Iff",
"Rat.instNormedField",
"Rat.instField",
"HasEquiv.Equiv",
"Nat",
"instHasEquivOfSetoid",
"Rat.instIsStrictOrderedRin... | true |
HomogeneousIdeal.toIdeal_comap | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Maps | [
"SetLike",
"NonAssocSemiring.toAddCommMonoidWithOne",
"GradedRingHom",
"AddMonoid.toAddZeroClass",
"AddSubmonoidClass",
"HomogeneousIdeal.comap",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"Ideal",
"GradedRing",
"GradedRingHom.instFunLike",
"AddMonoid",
"Ideal.comap",
"Semiring",
"Homogene... | true |
RCLike.norm_of_nonneg' | Mathlib.Analysis.RCLike.Basic | [
"Norm.norm",
"Eq.mpr",
"Real.instLE",
"Real",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"Real.instZero",
"Real.instAddMonoid",
"instReflLe",
"congrArg",
"AddMonoid.toAddZeroClass",
"AddMonoid.toZero",
"PartialOrder.toPreorder",
"Real.sqrt_mul_self",
"MonoidWithZeroHom.funLike",
"Preorde... | true |
CategoryTheory.Idempotents.KaroubiKaroubi.counitIso_hom_app_f_f | Mathlib.CategoryTheory.Idempotents.KaroubiKaroubi | [
"CategoryTheory.Idempotents.Karoubi.Hom.f",
"CategoryTheory.Functor",
"CategoryTheory.Idempotents.Karoubi",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Idempotents.KaroubiKaroubi.inverse",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.I... | true |
UInt8.add_left_neg | Init.Data.UInt.Lemmas | [
"UInt8.instOfNat",
"BitVec",
"instOfNatNat",
"UInt8.toBitVec",
"instAddUInt8",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instNegUInt8",
"Iff.mp",
"UInt8.toBitVec_inj",
"BitVec.add_left_neg",
"OfNat.ofNat",
"UInt8",
"Eq",
"Neg.neg"
] | true |
Lean.Elab.Term.instAddErrorMessageContextTermElabM | Lean.Elab.Term.TermElabM | [
"Pure.pure",
"Lean.MessageData",
"Lean.AddErrorMessageContext",
"instMonadReaderOfReaderTOfMonad",
"Lean.Elab.Term.instMonadTermElabM",
"Lean.AddErrorMessageContext.mk",
"Lean.Meta.State",
"MonadReader.read",
"Lean.Core.instMonadOptionsCoreM",
"Lean.Syntax",
"Lean.instMonadOptionsOfMonadLift",
... | true |
_private.Mathlib.MeasureTheory.Measure.Dirac.0.MeasureTheory.ae_dirac_eq._simp_1_1 | Mathlib.MeasureTheory.Measure.Dirac | [
"Filter.instMembership",
"MeasureTheory.ae",
"Compl.compl",
"Membership.mem",
"Set.instCompl",
"ENNReal",
"propext",
"Zero.toOfNat0",
"MeasureTheory.mem_ae_iff",
"ENNReal.instZero",
"MeasureTheory.OuterMeasureClass",
"OfNat.ofNat",
"Eq",
"DFunLike.coe",
"Filter",
"FunLike",
"Set"
] | false |
Prod.totallyDisconnectedSpace | Mathlib.Topology.Connected.TotallyDisconnected | [
"TotallyDisconnectedSpace.mk",
"Continuous.continuousOn",
"Set.univ",
"instTopologicalSpaceProd",
"IsPreconnected.image",
"Membership.mem",
"continuous_snd",
"continuous_fst",
"IsPreconnected.subsingleton",
"HasSubset.Subset",
"TotallyDisconnectedSpace",
"Prod.fst",
"TopologicalSpace",
"An... | true |
Ring.ordMonoidWithZeroHom_ne_zero | Mathlib.RingTheory.OrderOfVanishing.Noetherian | [
"Nontrivial",
"False",
"CommRing",
"MonoidHom.instFunLike",
"Equiv.instEquivLike",
"MonoidHom",
"congrArg",
"CommSemiring.toSemiring",
"AddMonoid.toAddZeroClass",
"MonoidWithZeroHom.funLike",
"Nat.instAddMonoid",
"Membership.mem",
"nonZeroDivisors",
"Exists",
"WithZero.instMulZeroOneClas... | true |
_private.Mathlib.Analysis.Asymptotics.Defs.0.Asymptotics.IsBigO.comp_snd._simp_1_1 | Mathlib.Analysis.Asymptotics.Defs | [
"Norm.norm",
"Real.instLE",
"Real",
"HMul.hMul",
"Asymptotics.isBigO_iff",
"Filter.Eventually",
"Asymptotics.IsBigO",
"Exists",
"Norm",
"LE.le",
"Real.instMul",
"propext",
"Eq",
"Filter",
"instHMul"
] | false |
Lean.Lsp.ServerCapabilities.renameProvider? | Lean.Data.Lsp.Capabilities | [
"Lean.Lsp.ServerCapabilities",
"Lean.Lsp.RenameOptions",
"Option"
] | true |
Module.Relations.Solution.IsPresentation.postcomp_uniq | Mathlib.Algebra.Module.Presentation.Basic | [
"congrArg",
"Module.Relations.Solution.IsPresentation",
"AddCommGroup.toAddCommMonoid",
"AddCommGroup",
"Module.Relations.Solution",
"Module.Relations.Solution.IsPresentation.postcomp_desc",
"LinearEquiv.toLinearMap",
"RingHomInvPair.ids",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
"Modul... | true |
Finsupp.mapRange.linearMap_apply | Mathlib.LinearAlgebra.Finsupp.Defs | [
"Finsupp.module",
"AddMonoid.toAddZeroClass",
"LinearMap.instFunLike",
"RingHom",
"LinearMap.map_zero",
"AddZeroClass.toAddZero",
"LinearMap",
"AddCommMonoid",
"Finsupp.instAddCommMonoid",
"AddZero.toZero",
"Semiring",
"Eq.refl",
"Finsupp.mapRange.linearMap",
"AddCommMonoid.toAddMonoid",
... | true |
Lean.Meta.Grind.Arith.Cutsat.FindIntValResult.found.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Search | [
"Lean.Meta.Grind.Arith.Cutsat.FindIntValResult.found",
"instOfNatNat",
"Int",
"Lean.Meta.Grind.Arith.Cutsat.FindIntValResult",
"instHAdd",
"HAdd.hAdd",
"Nat",
"Int._sizeOf_inst",
"Lean.Meta.Grind.Arith.Cutsat.FindIntValResult._sizeOf_inst",
"SizeOf.sizeOf",
"instAddNat",
"Eq.refl",
"OfNat.of... | true |
instBooleanAlgebraAsBoolAlg._proof_11 | Mathlib.Algebra.Ring.BooleanRing | [
"SemilatticeSup.mk",
"LT.mk",
"Lattice.toSemilatticeSup",
"HMul.hMul",
"CommSemiring.toSemiring",
"BooleanRing.sup",
"PartialOrder.toPreorder",
"instBooleanAlgebraAsBoolAlg._proof_5",
"Preorder.toLE",
"Preorder.mk",
"BooleanRing.toCommRing",
"AsBoolAlg",
"instBooleanAlgebraAsBoolAlg._proof_2... | false |
CategoryTheory.ObjectProperty.commShiftι | Mathlib.CategoryTheory.ObjectProperty.Shift | [
"CategoryTheory.ObjectProperty.liftCompιIso",
"CategoryTheory.ObjectProperty.ι",
"CategoryTheory.Functor.comp",
"CategoryTheory.ObjectProperty.hasShift",
"CategoryTheory.shiftFunctor",
"CategoryTheory.ObjectProperty.fullyFaithfulι",
"CategoryTheory.ObjectProperty.lift",
"CategoryTheory.ObjectProperty.... | true |
Mathlib.Tactic.LinearCombination.smul_eq_const | Mathlib.Tactic.LinearCombination.Lemmas | [
"instHSMul",
"SMul",
"Eq.rec",
"HSMul.hSMul",
"Eq",
"rfl"
] | true |
Nat.size_bit | Mathlib.Data.Nat.Size | [
"Nat.bit",
"Ne",
"instOfNatNat",
"Bool.true",
"Nat",
"Iff.mp",
"Bool",
"OfNat.ofNat",
"Nat.bit_ne_zero_iff",
"Nat.succ",
"Eq",
"Or.inr",
"Nat.size",
"Nat.binaryRec_eq"
] | true |
_private.Mathlib.Data.Erased.0.Erased.mk_out.match_1_1 | Mathlib.Data.Erased | [
"Erased",
"Subtype.casesOn",
"Exists",
"Subtype.mk",
"Eq"
] | false |
_private.Mathlib.Topology.Connected.Clopen.0.isPreconnected_iff_subset_of_disjoint_closed._simp_1_1 | Mathlib.Topology.Connected.Clopen | [
"Membership.mem",
"Exists",
"HasSubset.Subset",
"And",
"Set.not_subset",
"propext",
"Eq",
"Set.instMembership",
"Not",
"Set.instHasSubset",
"Set"
] | false |
_private.Batteries.Data.List.Perm.0.List.cons_subperm_of_not_mem_of_mem.match_1_3 | Batteries.Data.List.Perm | [
"List.Perm",
"List.cons",
"And.casesOn",
"List",
"And",
"Exists.casesOn",
"List.Subperm",
"And.intro",
"Exists.intro",
"List.Sublist"
] | false |
WithTop.strictAnti_iff | Mathlib.Order.WithBot | [
"Preorder.toLT",
"WithTop.instPreorder",
"WithTop.some",
"And",
"Iff",
"WithTop.top",
"StrictAnti",
"LT.lt",
"OrderDual",
"Top.top",
"WithTop.strictMono_iff",
"OrderDual.instPreorder",
"Preorder",
"WithTop"
] | true |
Subbimodule.mk._proof_2 | Mathlib.Algebra.Module.Bimodule | [
"AddMonoid.toAddZeroClass",
"AddSubsemigroup.carrier",
"Membership.mem",
"AddZeroClass.toAddZero",
"AddSubmonoid.toAddSubsemigroup",
"AddSubmonoid",
"AddCommMonoid",
"AddZero.toZero",
"AddSubmonoid.zero_mem'",
"AddZero.toAdd",
"Zero.toOfNat0",
"AddCommMonoid.toAddMonoid",
"OfNat.ofNat",
"S... | false |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceL._proof_9 | Std.Data.DTreeMap.Internal.Balancing | [
"False",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"HMul.hMul",
"Int.natCast_add",
"of_decide_eq_true",
"le_of_le_of_eq",
"Lean.Omega.Constraint.mk",
"Lean.Omega.Constraint.combine_sat'",
"Int.add_one_le_of_lt",
"HSub.hSub",
"Lean.Omega.Int.ofNat_sub_dichotomy",
"Lean.Omega.Int.add_con... | false |
Mathlib.Tactic.Ring.Common.ExSumNat.evalPos._unsafe_rec | Mathlib.Tactic.Ring.Common | [
"Mathlib.Tactic.Ring.Common.ExSumNat",
"Lean.Expr.const",
"Lean.Name.mkStr5",
"Option.some",
"Lean.Level",
"Mathlib.Tactic.Ring.Common.ExSumNat.evalPos._unsafe_rec",
"List.cons",
"instMonadOption",
"Lean.Literal.natVal",
"Option.none",
"Unit",
"Qq.Quoted",
"Lean.Level.zero",
"_private.Math... | false |
AlgebraicGeometry.Scheme.Cover.ColimitGluingData.trans._proof_4 | Mathlib.AlgebraicGeometry.ColimitsOver | [
"CategoryTheory.MorphismProperty.IsStableUnderBaseChangeAlong",
"CategoryTheory.MorphismProperty",
"CategoryTheory.MorphismProperty.instIsStableUnderBaseChangeAlongOfIsStableUnderBaseChange",
"AlgebraicGeometry.Scheme",
"CategoryTheory.PreZeroHypercover.f",
"AlgebraicGeometry.Scheme.OpenCover",
"Categor... | false |
HomotopicalAlgebra.RightHomotopyRel.leftHomotopy | Mathlib.AlgebraicTopology.ModelCategory.Homotopy | [
"CategoryTheory.Limits.hasFiniteCoproducts_of_hasFiniteColimits",
"HomotopicalAlgebra.PathObject",
"HomotopicalAlgebra.RightHomotopyRel.leftHomotopy._proof_3",
"CategoryTheory.Limits.hasColimitOfHasColimitsOfShape",
"HomotopicalAlgebra.Cylinder.LeftHomotopy",
"HomotopicalAlgebra.ModelCategory.cm1a",
"Ho... | true |
CategoryTheory.Limits.createsFiniteColimitsOfCreatesCoequalizersAndFiniteCoproducts | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | [
"CategoryTheory.Functor",
"CategoryTheory.Limits.CreatesFiniteCoproducts.creates",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.WalkingParallelPair",
"CategoryTheory.Limits.CreatesFiniteColimits",
"CategoryTheory.FinCategory.fintypeHom",
"CategoryTheory.CreatesColimit... | true |
Finset.coe_wcovBy_coe._simp_1 | Mathlib.Data.Finset.Grade | [
"Finset",
"Finset.coe_wcovBy_coe",
"PartialOrder.toPreorder",
"CompleteLattice.toConditionallyCompleteLattice",
"Finset.partialOrder",
"SetLike.coe",
"Finset.instSetLike",
"WCovBy",
"propext",
"CompleteBooleanAlgebra.toCompleteLattice",
"ConditionallyCompletePartialOrderSup.toPartialOrder",
"C... | false |
Ideal.comap_map_of_bijective | Mathlib.RingTheory.Ideal.Maps | [
"Iff.mpr",
"Submodule",
"Semiring.toModule",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"id",
"Ideal.map",
"Submodule.instPartialOrder",
"LE.le",
"Ideal",
"le_antisymm",
"Submodule.setLike",
"Ideal.le_comap_map",
"Ideal.comap",
"Function.Bijective",
"Semiring",
"... | true |
PEquiv.single_apply_of_ne | Mathlib.Data.PEquiv | [
"PEquiv.instFunLikeOption",
"PEquiv.single",
"Option.some",
"Ne",
"Ne.symm",
"Option.none",
"PEquiv",
"Eq",
"if_neg",
"DFunLike.coe",
"Option",
"DecidableEq"
] | true |
MeasureTheory.ae_ball_iff | Mathlib.MeasureTheory.OuterMeasure.AE | [
"MeasureTheory.ae",
"eventually_countable_ball",
"Filter.Eventually",
"Membership.mem",
"Iff",
"MeasureTheory.instCountableInterFilterAe",
"ENNReal",
"MeasureTheory.OuterMeasureClass",
"Set.Countable",
"Set.instMembership",
"FunLike",
"Set"
] | true |
_private.Batteries.Data.List.Lemmas.0.List.forIn'_cons.match_1.eq_1 | Batteries.Data.List.Lemmas | [
"ForInStep.done",
"ForInStep",
"List.forIn'_cons.match_1",
"Eq.refl",
"Eq",
"ForInStep.yield"
] | true |
_private.Std.Http.Data.Body.Stream.0.Std.Http.Body.Stream.mk._flat_ctor | Std.Http.Data.Body.Stream | [
"_private.Std.Http.Data.Body.Stream.0.Std.Http.Body.Channel.State",
"Std.Http.Body.Stream",
"Std.Mutex",
"_private.Std.Http.Data.Body.Stream.0.Std.Http.Body.Stream.mk"
] | false |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.Turan.0.SimpleGraph.IsTuranMaximal.not_adj_trans._simp_1_5 | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | [
"Finset.mem_singleton",
"Finset",
"Membership.mem",
"Finset.instSetLike",
"propext",
"Finset.instSingleton",
"Singleton.singleton",
"Eq",
"SetLike.instMembership"
] | false |
MeasureTheory.addMeasure_map_restrict_apply | Mathlib.MeasureTheory.Group.FundamentalDomain | [
"Eq.mpr",
"MeasureTheory.Measure",
"MeasurableSet",
"congrArg",
"MeasureTheory.Measure.map_apply",
"MeasureTheory.Measure.restrict_apply",
"Quotient.mk''",
"MeasureTheory.Measure.restrict",
"id",
"Set.instInter",
"Quotient.mk",
"Inter.inter",
"MeasurableSpace",
"AddAction",
"AddGroup",
... | true |
HahnSeries.embDomain | Mathlib.RingTheory.HahnSeries.Basic | [
"HahnSeries.support",
"PartialOrder.toPreorder",
"Classical.propDecidable",
"Preorder.toLE",
"Membership.mem",
"PartialOrder",
"HahnSeries.mk",
"dite",
"And",
"HahnSeries.coeff",
"Classical.choose",
"Zero.toOfNat0",
"Set.image",
"OrderEmbedding",
"OfNat.ofNat",
"HahnSeries",
"Eq",
... | true |
Std.DTreeMap.Internal.Impl.Const.getKey?_alter | Std.Data.DTreeMap.Internal.Lemmas | [
"Eq.mpr",
"Std.DTreeMap.Internal.Impl.WF.constAlter",
"Std.Internal.List.DistinctKeys",
"instDecidableEqOrdering",
"Std.DTreeMap.Internal.Impl.SizedBalancedTree.impl",
"Ord",
"Std.instLawfulBEqOrd",
"congrArg",
"beqOfOrd",
"Std.DTreeMap.Internal.Impl.Ordered.distinctKeys",
"Std.TransOrd",
"Std... | true |
OrderIso.emptySumLex_apply_inr | Mathlib.Data.Sum.Order | [
"Sum.Lex.LE",
"Equiv.instEquivLike",
"Lex",
"OrderIso.emptySumLex",
"Sum",
"Equiv",
"OrderIso",
"IsEmpty",
"LE",
"instFunLikeOrderIso",
"Sum.inr",
"Eq",
"DFunLike.coe",
"rfl",
"EquivLike.toFunLike",
"toLex"
] | true |
Lean.Elab.ConfigEval.EvalConfigItemView.mk.noConfusion | Lean.Elab.ConfigEval.DeriveEvalConfigItem | [
"Lean.Elab.ConfigEval.EvalConfigItemView.noConfusion",
"Lean.Syntax.Ident",
"id",
"Array",
"Lean.Elab.ConfigEval.EvalConfigItemHandler",
"Lean.Elab.ConfigEval.EvalConfigItemView.mk",
"Lean.Name",
"Lean.Elab.ConfigEval.EvalConfigItemView",
"Prod",
"Eq"
] | false |
Pi.addCancelCommMonoid | Mathlib.Algebra.Group.Pi.Basic | [
"AddCancelCommMonoid.mk",
"Pi.addLeftCancelMonoid",
"Pi.addCommMonoid",
"AddCancelCommMonoid",
"AddLeftCancelMonoid",
"Pi.addCancelCommMonoid._proof_2",
"AddCommMonoid",
"Pi.addCancelCommMonoid._proof_1",
"AddCancelCommMonoid.toAddCommMonoid",
"AddLeftCancelMonoid.toAddMonoid",
"AddCancelCommMon... | true |
Aesop.ForwardRule.mk._flat_ctor | Aesop.Rule.Forward | [
"Aesop.RuleName",
"Aesop.ForwardRule",
"Aesop.PremiseIndex",
"Aesop.RulePattern",
"Array",
"Nat",
"Aesop.ForwardRulePriority",
"Aesop.ForwardRuleInfo.mk",
"Aesop.ForwardRule.mk",
"Aesop.RuleTerm",
"Prod",
"Aesop.Slot",
"Option"
] | false |
QuaternionAlgebra.starAe._proof_4 | Mathlib.Algebra.Quaternion | [
"CommRing",
"Equiv.right_inv",
"AddMonoid.toAddSemigroup",
"Ring.toNonAssocRing",
"MulOpposite",
"MulOpposite.opAddEquiv",
"QuaternionAlgebra",
"NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring",
"QuaternionAlgebra.instStarRing",
"Equiv.toFun",
"NonAssocRing.toNonUnitalNonAssocRing",
"NonUnit... | false |
Std.ExtHashSet.erase_empty | Std.Data.ExtHashSet.Lemmas | [
"Std.ExtHashSet.instEmptyCollection",
"Std.ExtHashSet",
"_private.Std.Data.ExtHashSet.Lemmas.0.Std.ExtHashSet.ext",
"LawfulHashable",
"Unit",
"EquivBEq",
"Hashable",
"EmptyCollection.emptyCollection",
"BEq",
"Eq",
"Std.ExtHashSet.erase",
"Std.ExtHashMap.erase_empty"
] | true |
Std.Time.instReprDuration | Std.Time.Duration | [
"Std.Time.instReprDuration.repr",
"Repr.mk",
"Repr",
"Std.Time.Duration"
] | true |
Submodule.smul_of_tower_mem | Mathlib.Algebra.Module.Submodule.Defs | [
"Submodule",
"instHSMul",
"DistribMulAction.toDistribSMul",
"IsScalarTower",
"SubMulAction.smul_of_tower_mem",
"SMul",
"AddMonoid.toAddZeroClass",
"Membership.mem",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"Submodule.toSubMulAction",
"AddCommMonoid",
"AddZero.toZero",
"Subm... | true |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.Compacts.continuous_prod.match_1_5 | Mathlib.Topology.Sets.VietorisTopology | [
"Set.instSProd",
"SProd.sprod",
"setOf",
"Membership.mem",
"Prod.mk",
"HasSubset.Subset",
"TopologicalSpace",
"SetLike.coe",
"TopologicalSpace.Compacts.instSetLike",
"Prod",
"Prod.casesOn",
"Set.instMembership",
"Set.instHasSubset",
"TopologicalSpace.Compacts",
"Set"
] | false |
Nat.getD_toArray_rcc_eq_fallback | Init.Data.Range.Polymorphic.NatLemmas | [
"getElem?_neg",
"Std.Rcc.toArray",
"congrArg",
"Nat.size_rcc",
"HSub.hSub",
"Option.getD",
"instSubNat",
"instOfNatNat",
"LE.le",
"instLENat",
"Array",
"Std.PRange.instLawfulUpwardEnumerableLENat",
"Nat.not_lt._simp_1",
"Option.none",
"instHAdd",
"instHSub",
"HAdd.hAdd",
"Std.PRang... | true |
Lean.Doc.Block._sizeOf_2_eq | Lean.DocString.Types | [
"Lean.Doc.Block._sizeOf_5",
"Lean.Doc.Block._sizeOf_5_eq",
"congrArg",
"Lean.Doc.Block",
"Array.rec",
"instOfNatNat",
"Array.mk.sizeOf_spec",
"Array._sizeOf_inst",
"Array",
"Lean.Doc.Block._sizeOf_2",
"List",
"instHAdd",
"HAdd.hAdd",
"Nat",
"List._sizeOf_inst",
"Lean.Doc.ListItem._size... | false |
_private.Lean.Meta.Tactic.Simp.Main.0.Lean.Meta.Simp.reduceProjFn?.match_3 | Lean.Meta.Tactic.Simp.Main | [
"Unit.unit",
"Option.casesOn",
"Option.some",
"Lean.Expr",
"Option.none",
"Unit",
"Option"
] | false |
Lean.PrefixTreeNode.WellFormed.recOn | Lean.Data.PrefixTree | [
"Lean.PrefixTreeNode",
"Lean.PrefixTreeNode.empty",
"Ordering",
"Lean.PrefixTreeNode.WellFormed.rec",
"List",
"Lean.PrefixTreeNode.WellFormed.insertWff",
"Lean.PrefixTreeNode.WellFormed",
"Lean.PrefixTreeNode.insert",
"Lean.PrefixTreeNode.WellFormed.emptyWff"
] | false |
_private.Mathlib.AlgebraicTopology.SimplicialObject.Basic.0.CategoryTheory.SimplicialObject.δ_comp_δ''._simp_1_1 | Mathlib.AlgebraicTopology.SimplicialObject.Basic | [
"CategoryTheory.op_comp",
"Opposite",
"Quiver.opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.CategoryStruct.opposite",
"Quiver.Hom.op",
"Opposite.op",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheory.CategoryStruct",
"Eq.symm",
"Eq"
] | false |
ModuleCat.instModuleElemForallObjCompForgetLinearMapIdCarrierSections._proof_8 | Mathlib.Algebra.Category.ModuleCat.Limits | [
"Submodule.module'._proof_10",
"CategoryTheory.Functor",
"Submodule.module._proof_1",
"instHSMul",
"instSMulOfMul",
"Pi.addCommMonoid",
"ModuleCat.instModuleElemForallObjCompForgetLinearMapIdCarrierSections._proof_6",
"ModuleCat.instModuleElemForallObjCompForgetLinearMapIdCarrierSections._proof_4",
... | false |
_private.Mathlib.Analysis.Calculus.FDeriv.Measurable.0.FDerivMeasurableAux.D_subset_differentiable_set._proof_1_7 | Mathlib.Analysis.Calculus.FDeriv.Measurable | [
"Nat.instAtLeastTwoHAddOfNat",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat.instNeZeroSucc",
"Nat",
"instAddNat",
"OfNat.ofNat",
"Nat.AtLeastTwo"
] | false |
Set.ncard_eq_zero._auto_1 | Mathlib.Data.Set.Card | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.Name.mkStr2",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
Submonoid.LocalizationMap.mk' | Mathlib.GroupTheory.MonoidLocalization.Basic | [
"IsUnit.liftRight",
"Units.val",
"MonoidHom.instFunLike",
"HMul.hMul",
"MonoidHom",
"Monoid.toMulOneClass",
"Membership.mem",
"MonoidHom.restrict",
"Units",
"MulOne.toMul",
"Subtype",
"Submonoid.toMonoid",
"Submonoid.LocalizationMap.toMonoidHom",
"MulOneClass.toMulOne",
"Inv.inv",
"Com... | true |
CategoryTheory.ShortComplex.LeftHomologyMapData.compatibilityOfZerosOfIsColimitCokernelCofork_φH | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | [
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.WalkingParallelPair",
"CategoryTheory.Limits.CokernelCofork",
"CategoryTheory.ShortComplex",
"CategoryTheory.ShortComplex.X₁",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.... | true |
powCardSubgroup._proof_3 | Mathlib.GroupTheory.OrderOfElement | [
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"InvOneClass.toOne",
"HMul.hMul",
"Set.decidableMemPow",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"congrArg",
"ge_of_eq",
"Group",
"Classical.propDecidable",
"Group.toDivisionMonoid",
"Membership.mem",
"DivisionMonoid.toDivInvOneMo... | false |
_private.ImportGraph.Tools.FindHome.0.Lean.Name.findHome.match_1 | ImportGraph.Tools.FindHome | [
"Option.ctorIdx",
"_private.ImportGraph.Tools.FindHome.0.Lean.Name.findHome._sparseCasesOn_1",
"Option.some",
"Nat.hasNotBit",
"Lean.Environment",
"Option"
] | false |
String.Slice.toList_revPositions | Init.Data.String.Lemmas.Iterate | [
"String.Slice.revPositions",
"congrArg",
"Monad.toApplicative",
"String.Slice",
"Subtype",
"Ne",
"String.Slice.Model.revPositionsFrom",
"Id",
"Applicative.toPure",
"List",
"String.Slice.endPos",
"Std.Iter.toList",
"True",
"String.Slice.toList_revPositionsFrom",
"eq_self",
"of_eq_true",... | true |
Lean.Grind.CommRing.Expr.toPolyS._sunfold | Init.Grind.Ring.CommSemiringAdapter | [
"Lean.Grind.CommRing.Expr.toPolyS",
"instPowNat",
"Lean.Grind.CommRing.Mon.mult",
"Lean.Grind.CommRing.Poly",
"Lean.Grind.CommRing.Expr",
"Lean.Grind.CommRing.Expr.toPolyS.match_1",
"Int",
"Int.instNatPow",
"Lean.Grind.CommRing.Poly.combine",
"Nat.cast",
"Lean.Grind.CommRing.Poly.mul",
"Lean.G... | false |
Lean.instBEqAttributeKind.beq | Lean.Attributes | [
"instBEqOfDecidableEq",
"Lean.AttributeKind.ctorIdx",
"BEq.beq",
"Nat",
"Bool",
"instDecidableEqNat",
"Lean.AttributeKind"
] | true |
CategoryTheory.Subgroupoid.mk.injEq | Mathlib.CategoryTheory.Groupoid.Subgroupoid | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Eq.propIntro",
"CategoryTheory.Groupoid.inv",
"Membership.mem",
"CategoryTheory.Groupoid",
"CategoryTheory.Subgroupoid.mk.inj",
"CategoryTheory.Subgroupoid",
"CategoryTheory.CategoryStruct.comp",
"Eq.ndrec",
"Eq.refl",
"CategoryTheory.Ca... | true |
_private.Lean.Meta.Tactic.Cbv.Main.0.Lean.Meta.Tactic.Cbv.handleProj | Lean.Meta.Tactic.Cbv.Main | [
"Pure.pure",
"Lean.Core.instMonadTraceCoreM",
"_private.Lean.Meta.Tactic.Cbv.Main.0.Lean.Meta.Tactic.Cbv.handleProj.match_6",
"Lean.MessageData",
"Lean.Meta.Sym.share",
"Lean.instMonadAlwaysExceptStateRefT'",
"Lean.instExceptToTraceResult",
"Lean.Core.instMonadLiftIOCoreM",
"ReaderT",
"Lean.Meta.S... | true |
IsRadical | Mathlib.RingTheory.Nilpotent.Defs | [
"Dvd.dvd",
"Pow",
"Dvd",
"HPow.hPow",
"Nat",
"instHPow"
] | true |
Lean.MonadHashMapCacheAdapter.noConfusion | Lean.Util.MonadCache | [
"HEq.refl",
"Std.HashMap",
"Unit",
"eq_of_heq",
"Eq.ndrec",
"HEq",
"Hashable",
"Lean.MonadHashMapCacheAdapter.casesOn",
"Lean.MonadHashMapCacheAdapter",
"Lean.MonadHashMapCacheAdapter.noConfusionType",
"BEq",
"Eq"
] | false |
DFinsupp.Lex.orderBot._proof_1 | Mathlib.Data.DFinsupp.Lex | [
"AddMonoid.toAddZeroClass",
"Membership.mem",
"AddZeroClass.toAddZero",
"Multiset",
"Pi.instZero",
"AddCommMonoid",
"AddZero.toZero",
"Multiset.instMembership",
"DFinsupp.instZero._proof_1",
"Zero.toOfNat0",
"AddCommMonoid.toAddMonoid",
"Or",
"EmptyCollection.emptyCollection",
"OfNat.ofNat... | false |
_private.Mathlib.Computability.TuringMachine.Config.0.Turing.ToPartrec.Code.eval.match_1.eq_1 | Mathlib.Computability.TuringMachine.Config | [
"Unit.unit",
"Turing.ToPartrec.Code.eval.match_1",
"Turing.ToPartrec.Code.succ",
"Turing.ToPartrec.Code.tail",
"Unit",
"Turing.ToPartrec.Code.comp",
"Turing.ToPartrec.Code.case",
"Eq.refl",
"Turing.ToPartrec.Code.zero'",
"Eq",
"Turing.ToPartrec.Code.fix",
"Turing.ToPartrec.Code.cons",
"Turin... | true |
NFA.Path.ctorElimType | Mathlib.Computability.NFA | [
"cond",
"NFA.Path.cons",
"NFA.step",
"Nat.ble",
"NFA.Path",
"NFA",
"Membership.mem",
"PULift",
"NFA.Path.nil",
"List.cons",
"List",
"Nat",
"Set.instMembership",
"List.nil",
"Set"
] | false |
CategoryTheory.Oplax.StrongTrans.Hom._sizeOf_inst | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Bicategory",
"SizeOf.mk",
"CategoryTheory.OplaxFunctor",
"CategoryTheory.Oplax.StrongTrans.categoryStruct",
"SizeOf",
"CategoryTheory.Oplax.StrongTrans.Hom._sizeOf_1",
"CategoryTheory.Oplax.StrongTrans.Hom"
] | false |
_private.Lean.Meta.Basic.0.Lean.Meta.DefEqCacheKey.mk.inj | Lean.Meta.Basic | [
"UInt64",
"_private.Lean.Meta.Basic.0.Lean.Meta.DefEqCacheKey.mk",
"_private.Lean.Meta.Basic.0.Lean.Meta.DefEqCacheKey.mk.noConfusion",
"Lean.Expr",
"And",
"And.intro",
"Lean.Meta.DefEqCacheKey",
"Eq"
] | true |
_private.Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real.0.RealRMK.exists_nat_large | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real | [
"Filter.Tendsto.div_atTop",
"Real.instIsOrderedRing",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Real.partialOrder",
"Real.instLE",
"Real",
"Preorder.toLT",
"instHDiv",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Real.instArchimedean",
"HMul.hMul",
"IsTopologicalRing.toIsTopologicalSemi... | true |
AlgebraicGeometry.locallyQuasiFinite_iff_isFinite_fiber | Mathlib.AlgebraicGeometry.Morphisms.QuasiFinite | [
"AlgebraicGeometry.Spec",
"AlgebraicGeometry.Scheme",
"AlgebraicGeometry.PresheafedSpace.carrier",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CommRingCat",
"AlgebraicGeometry.instIsFiniteFiberToSpecResidueFieldOfLocallyQuasiFiniteOfQuasiCompact",
"AlgebraicGeometry.IsFinite",
"Algebrai... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.