name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
Std.Net.SocketAddressV6.mk.injEq | Std.Net.Addr | [
"Std.Net.SocketAddressV6.mk.inj",
"Std.Net.IPv6Addr",
"Eq.propIntro",
"Std.Net.SocketAddressV6.mk",
"Lean.injEq_helper",
"And",
"UInt16",
"Eq.ndrec",
"Eq.refl",
"Std.Net.SocketAddressV6",
"Eq"
] | true |
Lean.Elab.Tactic.GuardMsgs.FilterSpec.casesOn | Lean.Elab.GuardMsgs | [
"Lean.Elab.Tactic.GuardMsgs.FilterSpec.pass",
"Lean.Elab.Tactic.GuardMsgs.FilterSpec",
"Lean.Elab.Tactic.GuardMsgs.FilterSpec.check",
"Lean.Elab.Tactic.GuardMsgs.FilterSpec.drop",
"Lean.Elab.Tactic.GuardMsgs.FilterSpec.rec"
] | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastMul.go_le_size._unary | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul | [
"Std.Sat.AIG.RefVec.get",
"Eq.mpr",
"Std.Sat.AIG.Decl",
"False",
"Decidable.casesOn",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"Int.natCast_add",
"of_decide_eq_true",
"le_of_le_of_eq",
"Std.Sat.AIG.LawfulVecOperator.le_size_of_le_aig_size",
"Lean.Omega.Constraint.mk",
"Lean.Omega.Cons... | false |
CategoryTheory.Abelian.SpectralObject.opcyclesIsoH._proof_3 | Mathlib.Algebra.Homology.SpectralObject.Page | [
"CategoryTheory.Abelian.toPreadditive",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Abelian",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Abelian.SpectralObject",
"Int",
"CategoryTheory.Abelian.SpectralObject.shortComplex",
"CategoryTheory.ShortComplex.HasRightHom... | false |
Finpartition.card_filter_atomise_le_two_pow | Mathlib.Order.Partition.Finpartition | [
"Iff.mpr",
"Eq.mpr",
"le_refl",
"_private.Mathlib.Order.Partition.Finpartition.0.Finpartition.card_filter_atomise_le_two_pow._simp_1_1",
"_private.Mathlib.Order.Partition.Finpartition.0.Finpartition.card_filter_atomise_le_two_pow._simp_1_3",
"Iff.of_eq",
"congrArg",
"Finset",
"Nat.instMonoid",
"Fi... | true |
CategoryTheory.ObjectProperty.instHasZeroMorphismsFullSubcategory._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | [
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.ObjectProperty.ι",
"CategoryTheory.ObjectProperty.fullyFaithfulι",
"CategoryTheory.Limits.HasZeroMorphisms.zero_comp",
"CategoryTheory.Limits.HasZeroMorphisms.zero",
"CategoryTheory.Catego... | false |
Matrix.adjp.congr_simp | Mathlib.LinearAlgebra.Matrix.SemiringInverse | [
"instSubsingletonDecidable",
"Matrix",
"Decidable",
"Units",
"Eq.rec",
"Pi.instSubsingleton",
"Int",
"Int.instMonoid",
"CommSemiring",
"Fintype",
"Matrix.adjp",
"Eq.ndrec",
"Eq.refl",
"Subsingleton.elim",
"Eq",
"DecidableEq"
] | true |
NonemptyInterval.commMonoid._proof_8 | Mathlib.Algebra.Order.Interval.Basic | [
"CommMonoid.toCommSemigroup",
"IsOrderedMonoid",
"NonemptyInterval.instPow._proof_1",
"Preorder.toLE",
"LE.le",
"Prod.fst",
"Monoid.toPow",
"HPow.hPow",
"CommMonoid.toMonoid",
"Nat",
"instHPow",
"NonemptyInterval.toProd",
"covariant_swap_mul_of_covariant_mul",
"CommMonoid",
"Prod.snd",
... | false |
Finset.Ioc_map_sectL | Mathlib.Order.Interval.Finset.Basic | [
"Eq.mpr",
"False",
"Preorder.toLT",
"and_true",
"Prod.instLE_mathlib",
"instReflLe",
"congrArg",
"and_self",
"Finset",
"False.elim",
"PartialOrder.toPreorder",
"le_of_lt",
"Finset.ext",
"Preorder.toLE",
"Std.le_refl._simp_1",
"lt_self_iff_false._simp_1",
"Finset.map",
"Membership.m... | true |
Nat.instTransLeLt | Init.Data.Nat.Basic | [
"Nat.lt_of_le_of_lt",
"LE.le",
"instLENat",
"Trans",
"Nat",
"LT.lt",
"instLTNat",
"Trans.mk"
] | true |
Polynomial.Sequence.recOn | Mathlib.Algebra.Polynomial.Sequence | [
"WithBot",
"Polynomial.Sequence.mk",
"Polynomial.degree",
"instNatCastNat",
"Nat.cast",
"Polynomial",
"Polynomial.Sequence.rec",
"WithBot.natCast",
"Polynomial.Sequence",
"Nat",
"Semiring",
"Eq"
] | false |
DFinsupp.lmk_apply | Mathlib.LinearAlgebra.DFinsupp | [
"DFinsupp.lmk",
"DFinsupp.mk",
"Pi.addCommMonoid",
"Finset",
"Pi.module",
"AddMonoid.toAddZeroClass",
"LinearMap.instFunLike",
"Membership.mem",
"AddZeroClass.toAddZero",
"Set.Elem",
"LinearMap",
"AddCommMonoid",
"AddZero.toZero",
"SetLike.coe",
"Finset.instSetLike",
"DFinsupp.addCommM... | true |
IsLocalization.AtPrime.equivQuotMaximalIdeal._proof_1 | Mathlib.RingTheory.Localization.AtPrime.Basic | [
"CommRing",
"CommSemiring.toSemiring",
"Ideal",
"CommRing.toCommSemiring",
"Ideal.IsPrime",
"Ideal.IsMaximal",
"Ideal.IsMaximal.isPrime'"
] | false |
CategoryTheory.Limits.Cofan.op | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Products | [
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.Limits.Cofan",
"CategoryTheory.Limits.Fan.mk",
"Quiver.Hom.op",
"CategoryTheory.Limits.Fan",
"CategoryTheory.Discrete.functor",
"CategoryTheory.Limits.Cofan.inj",
"CategoryTheory.discreteCategory",
"Opposite.op",
"CategoryTheo... | true |
_private.Lean.Compiler.NameMangling.0.Lean.Name.demangleAux.decodeNum._mutual._proof_21 | Lean.Compiler.NameMangling | [
"PSum.casesOn",
"instHDiv",
"String",
"invImage",
"PSum",
"String.push",
"String.pushn",
"PSum.inr",
"PSigma.casesOn",
"id",
"HDiv.hDiv",
"instOfNatNat",
"String.instLTPos",
"Nat",
"LT.lt",
"Nat.instDiv",
"String.Pos",
"PSigma.mk",
"Lean.Name",
"String.Pos.instWellFoundedRelati... | false |
zpow_lt_zpow_iff_left | Mathlib.Algebra.Order.Group.Basic | [
"Preorder.toLT",
"IsOrderedMonoid",
"LinearOrder",
"PartialOrder.toPreorder",
"DivInvMonoid.toZPow",
"StrictMono.lt_iff_lt",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"Int",
"CommGroup",
"Group.toDivInvMonoid",
"Int.instLTInt",
"zpow_left_strictMono",
"Iff",
"HPow.hPow... | true |
MeasureTheory.OuterMeasure.trim_smul | Mathlib.MeasureTheory.OuterMeasure.Induced | [
"instHSMul",
"instSMulOfMul",
"CommSemiring.toSemiring",
"IsScalarTower",
"SMul",
"MeasureTheory.OuterMeasure.instSMul",
"MeasureTheory.OuterMeasure",
"ENNReal.instCommSemiring",
"instDistribOfSemiring",
"MeasurableSpace",
"Distrib.toMul",
"ENNReal",
"MeasureTheory.OuterMeasure.trim_op",
"... | true |
lipschitzOnWith_inv_iff._simp_2 | Mathlib.Analysis.Normed.Group.Uniform | [
"DivisionCommMonoid.toDivisionMonoid",
"DivInvOneMonoid.toInvOneClass",
"SeminormedCommGroup.toPseudoMetricSpace",
"Pi.instInv",
"DivisionMonoid.toDivInvOneMonoid",
"NNReal",
"CommGroup.toDivisionCommMonoid",
"PseudoEMetricSpace",
"Inv.inv",
"lipschitzOnWith_inv_iff",
"propext",
"LipschitzOnWi... | false |
_private.Lean.Parser.Extension.0.Lean.Parser.parserAttributeHooks._proof_1 | Lean.Parser.Extension | [
"Lean.Parser.ParserAttributeHook",
"ST.instNonemptyRef",
"IO.RealWorld",
"List",
"instNonemptyOfInhabited",
"Nonempty",
"ST.Ref",
"instInhabitedList"
] | false |
_private.Batteries.CodeAction.Misc.0.Batteries.CodeAction.instanceStub.collectFields.match_1 | Batteries.CodeAction.Misc | [
"Option.ctorIdx",
"Option.some",
"Nat.hasNotBit",
"Lean.Name",
"_private.Batteries.CodeAction.Misc.0.Batteries.CodeAction.instanceStub.collectFields._sparseCasesOn_1",
"Option"
] | false |
_private.Mathlib.Algebra.Quaternion.0.QuaternionAlgebra.star_eq_neg._simp_1_2 | Mathlib.Algebra.Quaternion | [
"AddGroup.toSubtractionMonoid",
"NegZeroClass.toNeg",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"instHAdd",
"AddGroup",
"AddGroup.toSubNegMonoid",
"HAdd.hAdd",
"propext",
"AddZero.toAdd",
"Zero.toOfNat0",
... | false |
Mathlib.Tactic.BicategoryLike.Normalize.Result.noConfusionType | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | [
"Mathlib.Tactic.BicategoryLike.NormalizedHom",
"Mathlib.Tactic.BicategoryLike.Mor₂Iso",
"Mathlib.Tactic.BicategoryLike.Normalize.Result.casesOn",
"Mathlib.Tactic.BicategoryLike.Normalize.Result",
"Eq"
] | false |
Matroid.ofIsBaseOfFinite_E | Mathlib.Combinatorics.Matroid.IndepAxioms | [
"Matroid.ExchangeProperty",
"Matroid.E",
"Set.Finite",
"Exists",
"Matroid.ofIsBaseOfFinite",
"HasSubset.Subset",
"Eq",
"rfl",
"Set.instHasSubset",
"Set"
] | true |
Subalgebra.pointwise_smul_toSubmodule | Mathlib.Algebra.Algebra.Subalgebra.Pointwise | [
"Subalgebra.pointwiseMulAction",
"Submodule.pointwiseDistribMulAction",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Submodule",
"Submodule.instAddCommMonoidWithOne",
"instHSMul",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"... | true |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.go._proof_6 | Init.Data.String.Pattern.String | [
"String.Slice",
"String.Slice.utf8ByteSize",
"LE.le",
"instLENat",
"Array",
"Nat",
"LT.lt",
"Decidable.byContradiction",
"instDecidableEqNat",
"instLTNat",
"_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable._proof_5",
"Eq",
"Array.size",
"Not"
... | false |
Pi.divInvMonoid._proof_4 | Mathlib.Algebra.Group.Pi.Basic | [
"DivInvMonoid.toInv",
"DivInvMonoid.toZPow",
"Pi.instInv",
"Int",
"Nat.cast",
"DivInvMonoid",
"funext",
"Inv.inv",
"HPow.hPow",
"DivInvMonoid.zpow_neg'",
"Nat",
"instNatCastInt",
"instHPow",
"Int.negSucc",
"Nat.succ",
"Eq"
] | false |
CategoryTheory.MonoidalCategory.selfLeftAction._proof_1 | Mathlib.CategoryTheory.Monoidal.Action.Basic | [
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.MonoidalCategory.tensorHom_def",
"CategoryTheory.MonoidalCategoryStruct.whiskerRight",
"CategoryTheory.MonoidalCategoryStruct.tens... | false |
ProbabilityTheory.bayesRisk_const | Mathlib.Probability.Decision.Risk.Basic | [
"ProbabilityTheory.bayesRisk",
"MeasureTheory.Measure",
"iInf",
"HMul.hMul",
"MeasureTheory.IsProbabilityMeasure.neZero",
"congrArg",
"CommSemiring.toSemiring",
"Set.univ",
"Measurable",
"ENNReal.measurableSpace",
"MeasureTheory.IsProbabilityMeasure.measure_univ",
"MeasureTheory.IsZeroOrProbab... | true |
Nat.choose_eq_asc_factorial_div_factorial | Mathlib.Data.Nat.Choose.Basic | [
"Eq.mpr",
"Nat.choose",
"instHDiv",
"HMul.hMul",
"Nat.factorial_dvd_ascFactorial",
"congrArg",
"Nat.mul_left_cancel",
"Nat.ascFactorial",
"id",
"HDiv.hDiv",
"instMulNat",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat.factorial",
"Nat",
"Nat.ascFactorial_eq_factorial_mul_choose",
"N... | true |
MeasurableSpace.DynkinSystem.ext_iff | Mathlib.MeasureTheory.PiSystem | [
"HEq.refl",
"Iff.rfl",
"Eq.casesOn",
"MeasurableSpace.DynkinSystem",
"MeasurableSpace.DynkinSystem.Has",
"Iff",
"MeasurableSpace.DynkinSystem.ext",
"Iff.intro",
"Eq.ndrec",
"Eq.refl",
"HEq",
"Eq.symm",
"Eq",
"Set"
] | true |
MvPFunctor.wRec | Mathlib.Data.PFunctor.Multivariate.W | [
"MvPFunctor.wPathDestLeft",
"MvPFunctor",
"PFunctor.A",
"PFunctor.B",
"MvPFunctor.wRec.match_1",
"PFunctor.W",
"instOfNatNat",
"MvPFunctor.A",
"MvPFunctor.wPathDestRight",
"WType.mk",
"instHAdd",
"HAdd.hAdd",
"MvPFunctor.WPath",
"Nat",
"MvPFunctor.wp",
"MvPFunctor.B",
"MvPFunctor.las... | true |
IsLocalRing.instCommRingResidueField._proof_12 | Mathlib.RingTheory.LocalRing.ResidueField.Defs | [
"IsLocalRing.instCommRingResidueField._aux_4",
"CommRing",
"Semiring.toModule",
"AddMonoid.toAddSemigroup",
"CommSemiring.toSemiring",
"IsLocalRing.instCommRingResidueField._proof_3",
"Submodule.Quotient.addCommMonoid._proof_1",
"Add.mk",
"AddMonoid.mk",
"IsLocalRing.maximalIdeal",
"IsLocalRing.... | false |
_aux_Mathlib_Data_Finsupp_Defs___unexpand_Finsupp_1 | Mathlib.Data.Finsupp.Defs | [
"Pure.pure",
"cond",
"Lean.TSyntax",
"Unit.unit",
"Lean.MonadRef.mkInfoFromRefPos",
"instMonadExceptOfMonadExceptOf",
"Lean.SourceInfo",
"Lean.PrettyPrinter.UnexpandM",
"MonadExcept.throw",
"Lean.Syntax.isOfKind",
"EStateM.instMonad",
"Lean.Syntax.atom",
"Lean.TSyntax.mk",
"Lean.Syntax",
... | false |
NonUnitalRingHom.coe_mul | Mathlib.Algebra.Ring.Hom.Defs | [
"HMul.hMul",
"MulZeroClass.toMul",
"Function.comp",
"NonUnitalRingHom.instFunLike",
"MonoidWithZero.toMulZeroOneClass",
"NonUnitalRingHom.instMonoidWithZero",
"MulZeroOneClass.toMulZeroClass",
"NonUnitalRingHom",
"NonUnitalNonAssocSemiring",
"Eq",
"DFunLike.coe",
"rfl",
"instHMul"
] | true |
instDecidableEqExcept_batteries.decEq | Batteries.Lean.Except | [
"Decidable.isTrue",
"instDecidableEqExcept_batteries.decEq.match_1",
"Except.ok",
"Decidable",
"Except.error",
"instDecidableEqExcept_batteries.decEq._proof_1",
"dite",
"instDecidableEqExcept_batteries.decEq._proof_3",
"instDecidableEqExcept_batteries.decEq._proof_5",
"Eq.ndrec",
"instDecidableE... | true |
_private.Lean.Elab.Tactic.Do.VCGen.SuggestInvariant.0.Lean.Elab.Tactic.Do.ClassifyInvariantUseResult.unknownInvariantUse.elim | Lean.Elab.Tactic.Do.VCGen.SuggestInvariant | [
"PULift.up",
"_private.Lean.Elab.Tactic.Do.VCGen.SuggestInvariant.0.Lean.Elab.Tactic.Do.ClassifyInvariantUseResult.ctorElim",
"Nat",
"_private.Lean.Elab.Tactic.Do.VCGen.SuggestInvariant.0.Lean.Elab.Tactic.Do.ClassifyInvariantUseResult",
"_private.Lean.Elab.Tactic.Do.VCGen.SuggestInvariant.0.Lean.Elab.Tactic... | false |
NonUnitalSubsemiring.mem_carrier | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | [
"Iff.rfl",
"AddMonoid.toAddZeroClass",
"AddSubsemigroup.carrier",
"Membership.mem",
"AddZeroClass.toAddZero",
"AddSubmonoid.toAddSubsemigroup",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"Iff",
"NonUnitalSubsemiring.toAddSubmonoid",
"NonUnitalSubsemiring.instSetLike",
"NonUnitalSubsemiring",
... | true |
_private.Lean.Data.Json.FromToJson.Basic.0.Lean.Json.getTag?._sparseCasesOn_1 | Lean.Data.Json.FromToJson.Basic | [
"Lean.Json.bool",
"Lean.Json",
"Lean.Json.rec",
"Nat.ne_of_beq_eq_false",
"Lean.Json.obj",
"String",
"Lean.Json.ctorIdx",
"Lean.JsonNumber",
"Nat.shiftRight",
"Nat.hasNotBit",
"instOfNatNat",
"Ord.compare",
"Array",
"Lean.Json.arr",
"Std.TreeMap.Raw",
"Nat.land",
"List",
"Lean.Json... | false |
CStarAlgebra.isStrictlyPositive_iff_isSelfAdjoint_and_spectrum_pos | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | [
"IsSelfAdjoint",
"Real.partialOrder",
"Real",
"Algebra.to_smulCommClass",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"instStarRingReal",
"HMul.hMul",
"IsScalarTower.right",
"spectrum",
"Ring.toNonAssocRing",
"IsTopologicalRing.toIsTopologicalSemiring",
"Real.instZero",
"CFC.sqrt",
"P... | true |
Lean.Grind.Linarith.instBEqExpr.beq._sparseCasesOn_2 | Init.Grind.Ordered.Linarith | [
"Lean.Grind.Linarith.Expr.zero",
"Lean.Grind.Linarith.Expr",
"Lean.Grind.Linarith.Expr.ctorIdx",
"Lean.Grind.Linarith.Expr.neg",
"Lean.Grind.Linarith.Expr.intMul",
"Nat.ne_of_beq_eq_false",
"Lean.Grind.Linarith.Expr.natMul",
"Nat.shiftRight",
"Lean.Grind.Linarith.Expr.rec",
"Lean.Grind.Linarith.Ex... | false |
_private.Mathlib.Topology.LocallyConstant.Basic.0.LocallyConstant.piecewise'._simp_1 | Mathlib.Topology.LocallyConstant.Basic | [
"Set.univ",
"Set.eq_univ_iff_forall",
"Membership.mem",
"propext",
"Eq",
"Set.instMembership",
"Set"
] | false |
_private.Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone.0.CochainComplex.mappingCocone.δ_descCochain._proof_1_3 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | [
"Lean.RArray.leaf",
"False",
"Int.Linear.eq_eq_true",
"congrArg",
"Classical.byContradiction",
"Int.Linear.Expr.add",
"id",
"False.casesOn",
"instOfNatNat",
"Int",
"Bool.true",
"instHAdd",
"instOfNat",
"HAdd.hAdd",
"Nat",
"True",
"Bool",
"Int.instAdd",
"Int.Linear.Expr.var",
"L... | false |
Complex.tan_eq_one_sub_tan_half_sq_div_one_add_tan_half_sq | Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex | [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"instHDiv",
"HMul.hMul",
"GroupWithZero.toDivInvMonoid",
"CharZero.NeZero.two",
"MulZeroClass.toMul",
"congrArg",
"Nat.instAtLeastTwoHAddOfNat",
"AddGroupWithOne.toAddMonoidWithOne",
"HSub.hSub",
"Complex.instDivInvMonoid",
"Complex.instMul",
"Eq... | true |
CategoryTheory.StructuredArrow.prodEquivalence_inverse | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | [
"CategoryTheory.Functor",
"CategoryTheory.StructuredArrow.prodEquivalence",
"Prod.mk",
"CategoryTheory.Functor.prod",
"CategoryTheory.prod'",
"Eq.refl",
"CategoryTheory.StructuredArrow.prodInverse",
"CategoryTheory.instCategoryStructuredArrow",
"Prod",
"Eq",
"CategoryTheory.StructuredArrow",
"... | true |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Proof.0.Lean.Meta.Grind.Arith.CommRing.NormResult.casesOn | Lean.Meta.Tactic.Grind.Arith.CommRing.Proof | [
"_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Proof.0.Lean.Meta.Grind.Arith.CommRing.NormResult",
"_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Proof.0.Lean.Meta.Grind.Arith.CommRing.NormResult.mk",
"Lean.Expr",
"Array",
"_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Proof.0.Lean.Meta.Grind.Arith.CommR... | false |
Std.IterM.Equiv.forIn_eq | Std.Data.Iterators.Lemmas.Consumers.Monadic.Loop | [
"Pure.pure",
"Eq.mpr",
"Std.IterM.DefaultConsumers.forIn'_eq_match_step.match_3",
"False",
"bind_congr",
"Std.IterStep.bundledQuotient",
"Std.IterStep",
"LawfulMonadLiftT",
"_private.Std.Data.Iterators.Lemmas.Consumers.Monadic.Loop.0.Std.IterM.Equiv.forIn_eq._simp_1_1",
"congrArg",
"Std.Shrink",... | true |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.size_clearUnit | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | [
"congrArg",
"instOfNatNat",
"Prod.fst",
"Array.size_modify",
"Array",
"And",
"Nat",
"LT.lt",
"True",
"eq_self",
"Bool",
"of_eq_true",
"Std.Tactic.BVDecide.LRAT.Internal.Assignment",
"Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.clearUnit",
"Std.Tactic.BVDecide.LRAT.Internal.Assignmen... | true |
PEquiv.refl._proof_1 | Mathlib.Data.PEquiv | [
"Option.some",
"eq_comm",
"Iff",
"Eq",
"Option"
] | false |
HomotopicalAlgebra.Precylinder.i₁ | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"HomotopicalAlgebra.Precylinder.I",
"HomotopicalAlgebra.Precylinder",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.Category"
] | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded.State.capacity | Std.Sync.Channel | [
"_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded.State",
"Nat"
] | true |
_private.Mathlib.Order.Interval.Set.LinearOrder.0.Set.Ioc_eq_Ioc_iff._proof_1_4 | Mathlib.Order.Interval.Set.LinearOrder | [
"Lean.Grind.eq_false_of_not_eq_true",
"False",
"Lean.Grind.and_eq_of_eq_true_right",
"Lean.Grind.not_and",
"LinearOrder",
"Classical.byContradiction",
"PartialOrder.toPreorder",
"Lean.Grind.Order.eq_of_le_of_le",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"Eq.mp",
"DistribLattice.toLatt... | false |
Std.DTreeMap.Const.getKey_modify_self | Std.Data.DTreeMap.Lemmas | [
"Std.DTreeMap",
"Std.DTreeMap.Const.modify",
"Ord.mk",
"Membership.mem",
"Ordering",
"Std.DTreeMap.Internal.Impl.Const.getKey_modify_self",
"Std.DTreeMap.inner",
"Std.TransCmp",
"Std.DTreeMap.instMembership",
"Std.DTreeMap.wf",
"Inhabited",
"Eq",
"Std.DTreeMap.getKey"
] | true |
CategoryTheory.CartesianMonoidalCategory.liftEquiv._proof_2 | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | [
"Function.LeftInverse",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.SemiCartesianMonoidalCategory.snd",
"Prod.mk",
"CategoryTheory.CartesianMonoidalCategory.lift",
"CategoryTheory.SemiCartesianMonoidalCategory.toMonoidalCategory",
"CategoryTheory.CartesianMono... | false |
ULift.instLawfulApplicative_mathlib | Mathlib.Control.ULift | [
"Applicative.toSeqLeft",
"Pure.pure",
"LawfulApplicative.mk",
"Monad.toApplicative",
"ULift",
"_private.Mathlib.Control.ULift.0.ULift.instLawfulApplicative_mathlib.match_1",
"Function.comp",
"Seq.seq",
"Applicative.toPure",
"Unit",
"ULift.instMonad_mathlib",
"_private.Mathlib.Control.ULift.0.U... | true |
WeierstrassCurve.toShortNFOfCharThree_a₂ | Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms | [
"Mathlib.Meta.NormNum.isInt_pow",
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"CharP.cast_eq_zero",
"AddGroup.toSubtractionMonoid",
"Mathlib.Tactic.Ring.Common.neg_zero",
"Units.val",
"Eq.mpr",
"NegZeroClass.toNeg",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Mathlib.Tactic.Ring.Common.neg_mul",
"... | true |
Nat.shiftLeft_zero | Init.Data.Nat.Lemmas | [
"HShiftLeft.hShiftLeft",
"instOfNatNat",
"Nat",
"instHShiftLeftOfShiftLeft",
"OfNat.ofNat",
"Eq",
"Nat.instShiftLeft",
"rfl"
] | true |
Std.TreeMap.Raw.minKey?_eq_none_iff._simp_1 | Std.Data.TreeMap.Raw.Lemmas | [
"Ordering",
"Std.TransCmp",
"Std.TreeMap.Raw.WF",
"Std.TreeMap.Raw",
"Bool.true",
"Option.none",
"Std.TreeMap.Raw.isEmpty",
"Std.TreeMap.Raw.minKey?",
"Std.TreeMap.Raw.minKey?_eq_none_iff",
"propext",
"Bool",
"Eq",
"Option"
] | false |
Submodule.projectionL_apply_eq_zero_iff | Mathlib.Topology.Algebra.Module.Complement | [
"Submodule",
"AddCommGroup.toAddCommMonoid",
"ContinuousLinearMap.funLike",
"Submodule.projectionL",
"Membership.mem",
"AddCommGroup",
"SubtractionMonoid.toSubNegZeroMonoid",
"Submodule.IsTopCompl.isCompl",
"Submodule.IsTopCompl",
"SubNegZeroMonoid.toNegZeroClass",
"SubtractionCommMonoid.toSubtr... | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.instNonemptyUnbounded | Std.Sync.Channel | [
"Classical.ofNonempty",
"_private.Std.Sync.Channel.0.Std.CloseableChannel.Unbounded",
"_private.Std.Sync.Channel.0.Std.CloseableChannel.Unbounded.mk",
"_private.Std.Sync.Channel.0.Std.CloseableChannel.Unbounded.State",
"Nonempty.intro",
"_private.Std.Sync.Channel.0.Std.CloseableChannel.Unbounded.instNonem... | true |
Std.TreeMap.Raw.isSome_apply_of_mem_filterMap | Std.Data.TreeMap.Raw.Lemmas | [
"GetElem?.toGetElem",
"Std.TreeMap.Raw.WF.out",
"Membership.mem",
"Ordering",
"Std.TreeMap.Raw.instMembership",
"Std.TreeMap.Raw.filterMap",
"Std.TransCmp",
"Std.TreeMap.Raw.WF",
"Std.TreeMap.Raw.inner",
"GetElem.getElem",
"Std.TreeMap.Raw",
"Bool.true",
"Std.TreeMap.Raw.mem_of_mem_filterMap... | true |
MulEquiv.finite_left | Mathlib.Data.Finite.Prod | [
"Finite",
"Mul",
"Equiv",
"MulEquiv.toEquiv",
"Equiv.finite_left",
"MulEquiv.toEquiv_injective",
"MulEquiv",
"Finite.of_injective"
] | true |
QuotientAddGroup.comapMk'OrderIso._proof_2 | Mathlib.GroupTheory.QuotientGroup.Basic | [
"AddSubgroup.comap",
"PartialOrder.toPreorder",
"AddSubgroup.instPartialOrder",
"Preorder.toLE",
"QuotientAddGroup.Quotient.addGroup",
"Subtype",
"LE.le",
"QuotientAddGroup.mk'",
"AddSubgroup",
"AddSubgroup.Normal",
"HasQuotient.Quotient",
"AddGroup",
"QuotientAddGroup.instHasQuotientAddSubg... | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.twoPow_le_toInt_sub_toInt_iff._proof_1_4 | Init.Data.BitVec.Lemmas | [
"instPowNat",
"instDecidableNot",
"Int.instDiv",
"False",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"Lean.Omega.Int.le_of_not_lt",
"instHDiv",
"HMul.hMul",
"of_decide_eq_true",
"le_of_le_of_eq",
"Lean.Omega.Constraint.mk",
"Lean.Omega.Constraint.combine_sat'",
"Int.add_one_le_of_lt",... | false |
Vector.toList_insertIdx | Init.Data.Vector.Lemmas | [
"Vector",
"congrArg",
"List.insertIdx",
"instOfNatNat",
"LE.le",
"instLENat",
"Array.toList",
"List",
"instHAdd",
"HAdd.hAdd",
"Array.toList_insertIdx",
"Nat",
"True",
"eq_self",
"of_eq_true",
"instAddNat",
"congrFun'",
"Vector.insertIdx",
"OfNat.ofNat",
"Vector.toList",
"Eq"... | true |
CategoryTheory.MorphismProperty.inverseImage_iff._simp_1 | Mathlib.CategoryTheory.MorphismProperty.Basic | [
"CategoryTheory.MorphismProperty",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.MorphismProperty.inverseImage",
"CategoryTheory.Functor.map",
"propext",
"CategoryTheory.MorphismProperty.inverseImage_iff",
"CategoryTheory.Category.toCategoryStruct"... | false |
Std.BundledIterM.mk.injEq | Std.Data.Iterators.Lemmas.Equivalence.Basic | [
"Std.BundledIterM.mk.inj",
"Eq.propIntro",
"Lean.injEq_helper",
"HEq.homo_ndrec",
"Std.Iterator",
"And",
"Eq.ndrec",
"Std.BundledIterM.mk",
"Eq.refl",
"HEq",
"Std.IterM",
"Std.BundledIterM",
"Eq"
] | true |
IsInvariantSubring.coe_subtypeHom | Mathlib.Algebra.Ring.Action.Invariant | [
"Monoid",
"IsInvariantSubring.subtypeHom",
"Subring.instSetLike",
"Ring.toNonAssocRing",
"Monoid.toMulOneClass",
"Membership.mem",
"Subtype",
"MulSemiringActionHom",
"Subring.toRing",
"MulOneClass.toMulOne",
"MonoidHom.id",
"Subring",
"MulSemiringActionHom.instFunLike",
"MulSemiringAction"... | true |
RingCon.instNonUnitalNonAssocRingQuotient._proof_1 | Mathlib.RingTheory.Congruence.Defs | [
"NonUnitalNonAssocRing",
"NegZeroClass.toNeg",
"RingCon.toCon",
"instHSMul",
"AddMonoid.toAddSemigroup",
"AddMonoid.toAddZeroClass",
"NonUnitalNonAssocRing.toAddCommGroup",
"HSub.hSub",
"AddMonoid.toNSMul",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"AddCommGroup.toAddGroup",
"Quotient.mk''",... | false |
Fin.foldr_eq_foldrM | Init.Data.Fin.Fold | [
"Pure.pure",
"Fin.foldrM_zero",
"instNeZeroNatHAdd_1",
"Fin.foldr_succ",
"Nat.recAux",
"Fin.succ",
"Fin.foldrM",
"congrArg",
"Monad.toApplicative",
"Fin.foldr",
"Fin.foldr_zero",
"Fin.foldrM_succ",
"LawfulMonad.bind_pure_comp",
"Fin.instOfNat",
"instOfNatNat",
"Id.run",
"Id",
"Appl... | true |
CategoryTheory.Presheaf.instIsLeftKanExtensionFunctorOppositeTypeIdCompUliftYonedaOfPreservesColimitsOfSizeOfHasPointwiseLeftKanExtension | Mathlib.CategoryTheory.Limits.Presheaf | [
"CategoryTheory.Limits.PreservesColimitsOfSize",
"CategoryTheory.Functor",
"Opposite",
"CategoryTheory.Functor.IsLeftKanExtension",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Iso.refl",
"CategoryTheory.Presheaf.isLeftKanExten... | true |
Lean.Elab.WF.isWfParam? | Lean.Elab.PreDefinition.WF.Preprocess | [
"Lean.Expr.isAppOfArity",
"Lean.Expr.appArg!",
"Option.some",
"Lean.Expr",
"instDecidableEqBool",
"instOfNatNat",
"Bool.true",
"Option.none",
"Nat",
"Bool",
"OfNat.ofNat",
"Lean.Name.mkStr1",
"Eq",
"Option",
"ite"
] | true |
_private.Lean.Elab.DocString.0.Lean.Doc.InternalState.mk | Lean.Elab.DocString | [
"_private.Lean.Elab.DocString.0.Lean.Doc.InternalState.mk",
"String",
"Lean.Doc.InternalState",
"Std.HashMap",
"instHashableString",
"instBEqOfDecidableEq",
"_private.Lean.Elab.DocString.0.Lean.Doc.Ref",
"instDecidableEqString",
"Lean.ElabInline",
"Lean.Doc.Inline"
] | true |
CategoryTheory.sheafComposeNatTrans | Mathlib.CategoryTheory.Sites.PreservesSheafification | [
"CategoryTheory.sheafCompose",
"CategoryTheory.Functor",
"Opposite",
"Equiv.instEquivLike",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.Adjunction.unit",
"CategoryTheory.Functor.id",
"Equiv",
"Categor... | true |
Real.comap_exp_nhds_zero | Mathlib.Analysis.SpecialFunctions.Exp | [
"Real",
"Set.Ioi",
"Real.instZero",
"comap_nhdsWithin_range",
"congrArg",
"nhdsWithin",
"PseudoMetricSpace.toUniformSpace",
"nhds",
"Real.exp",
"Real.range_exp",
"True",
"Real.comap_exp_nhdsGT_zero",
"eq_self",
"of_eq_true",
"Filter.atBot",
"Zero.toOfNat0",
"congrFun'",
"Real.pseud... | true |
_private.Mathlib.Topology.Algebra.Group.Basic.0.continuous_of_tendsto_nhds_one._simp_1_1 | Mathlib.Topology.Algebra.Group.Basic | [
"Filter.map",
"Filter.tendsto_map'_iff",
"Function.comp",
"Filter.Tendsto",
"propext",
"Eq",
"Filter"
] | false |
CategoryTheory.Functor.LaxRightLinear.μᵣ_associativity_assoc | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | [
"CategoryTheory.Category.assoc",
"CategoryTheory.Functor",
"CategoryTheory.Functor.LaxRightLinear",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionObj",
"Eq.mp",
"id",
"Catego... | true |
Nat.finMulAntidiag_zero_right | Mathlib.Algebra.Order.Antidiag.Nat | [
"Finset",
"instOfNatNat",
"Finset.instEmptyCollection",
"Nat",
"Nat.finMulAntidiag",
"EmptyCollection.emptyCollection",
"OfNat.ofNat",
"Fin",
"Eq",
"rfl"
] | true |
ContinuousMap.HomotopyRel.pi | Mathlib.Topology.Homotopy.Product | [
"Pi.topologicalSpace",
"ContinuousMap.Homotopy.pi",
"ContinuousMap.HomotopyRel",
"ContinuousMap",
"Membership.mem",
"ContinuousMap.HomotopyWith.mk",
"TopologicalSpace",
"ContinuousMap.HomotopyRel.pi._proof_2",
"ContinuousMap.HomotopyWith.toHomotopy",
"ContinuousMap.Homotopy",
"Eq",
"Set.instMe... | true |
derangements.Equiv.RemoveNone.fiber_none | Mathlib.Combinatorics.Derangements.Basic | [
"Eq.mpr",
"False",
"Equiv.instEquivLike",
"congrArg",
"Membership.mem",
"Exists",
"Eq.mp",
"id",
"Equiv",
"derangements.Equiv.RemoveNone.mem_fiber",
"And.casesOn",
"Option.none",
"And",
"Exists.casesOn",
"Set.eq_empty_iff_forall_notMem",
"Equiv.Perm",
"propext",
"Equiv.removeNone",... | true |
List.getLast_getLast_splitBy | Mathlib.Data.List.SplitBy | [
"Iff.mpr",
"List.getLast",
"congrArg",
"List.flatten_ne_nil_iff",
"Membership.mem",
"Exists",
"List.getLast_getLast_eq_getLast_flatten",
"Ne",
"List.ne_nil_of_mem_splitBy",
"List.splitBy",
"List",
"And",
"List.instMembership",
"List.splitBy_ne_nil",
"And.intro",
"True",
"eq_self",
... | true |
instAlgebraUniversalEnvelopingAlgebra | Mathlib.Algebra.Lie.UniversalEnveloping | [
"CommRing",
"instAlgebraUniversalEnvelopingAlgebra._aux_3",
"Algebra",
"instRingUniversalEnvelopingAlgebra",
"UniversalEnvelopingAlgebra",
"SMul.mk",
"Algebra.mk",
"LieRing",
"CommRing.toCommSemiring",
"instAlgebraUniversalEnvelopingAlgebra._proof_5",
"LieAlgebra",
"instAlgebraUniversalEnvelop... | true |
_private.Mathlib.CategoryTheory.Limits.MorphismProperty.0.CategoryTheory.CostructuredArrow.isClosedUnderColimitsOfShape.match_1_1 | Mathlib.CategoryTheory.Limits.MorphismProperty | [
"CategoryTheory.MorphismProperty",
"CategoryTheory.MorphismProperty.costructuredArrowObj",
"CategoryTheory.Functor",
"CategoryTheory.ObjectProperty.colimitsOfShape",
"CategoryTheory.CostructuredArrow",
"CategoryTheory.ObjectProperty.ColimitOfShape",
"Nonempty.intro",
"CategoryTheory.instCategoryCostru... | false |
Lean.Meta.Grind.Arith.CommRing.checkInvariants | Lean.Meta.Tactic.Grind.Arith.CommRing.Inv | [
"Pure.pure",
"Lean.Meta.Grind.Arith.CommRing.RingM.run",
"Lean.Meta.Grind.GrindM",
"Unit.unit",
"Lean.Meta.Grind.Goal",
"Std.Rio.instForIn'InferInstanceMembershipOfLawfulUpwardEnumerableOfLawfulUpwardEnumerableLTOfLawfulUpwardEnumerableLeast?OfMonadOfFiniteIteratorId",
"Lean.Meta.Grind.Arith.CommRing.ge... | true |
FiniteArchimedeanClass.closedBallAddSubgroup.eq_1 | Mathlib.Algebra.Order.Archimedean.Class | [
"AddCommGroup.toAddCommMonoid",
"LinearOrder",
"ArchimedeanClass.instLinearOrder",
"PartialOrder.toPreorder",
"Preorder.toLE",
"AddCommGroup.toAddGroup",
"SemilatticeInf.toPartialOrder",
"UpperSet.Ici",
"AddCommGroup",
"DistribLattice.toLattice",
"Ne",
"FiniteArchimedeanClass",
"AddSubgroup"... | true |
_private.Mathlib.MeasureTheory.Integral.Average.0.MeasureTheory.exists_setLAverage_le.match_1_1 | Mathlib.MeasureTheory.Integral.Average | [
"MeasureTheory.Measure",
"MeasureTheory.laverage",
"setOf",
"Membership.mem",
"MeasureTheory.Measure.restrict",
"LE.le",
"And.casesOn",
"MeasurableSpace",
"And",
"Set.Nonempty",
"Exists.casesOn",
"And.intro",
"ENNReal.instLE",
"ENNReal",
"Exists.intro",
"Set.instMembership",
"Set"
] | false |
ENNReal.nhdsGT_zero_neBot | Mathlib.Topology.Instances.ENNReal.Lemmas | [
"Set.Ioi",
"Filter.NeBot",
"nhdsWithin",
"PartialOrder.toPreorder",
"NNReal",
"ENNReal.nhdsGT_coe_neBot",
"NNReal.instZero",
"ENNReal",
"ENNReal.instPartialOrder",
"Zero.toOfNat0",
"ENNReal.instTopologicalSpace",
"ENNReal.instZero",
"OfNat.ofNat"
] | true |
Algebra.Extension.H1Cotangent.equiv._proof_4 | Mathlib.RingTheory.Extension.Cotangent.Basic | [
"CommRing",
"CommSemiring.toSemiring",
"RingHomInvPair",
"CommRing.toCommSemiring",
"RingHomInvPair.ids",
"RingHom.id",
"Semiring.toNonAssocSemiring"
] | false |
Std.HashMap.Raw.recOn | Std.Data.HashMap.Raw | [
"Std.DHashMap.Raw",
"Std.HashMap.Raw",
"Std.HashMap.Raw.rec",
"Std.HashMap.Raw.mk"
] | false |
CategoryTheory.ObjectProperty.prop_retractClosure_iff | Mathlib.CategoryTheory.ObjectProperty.Retract | [
"Iff.rfl",
"Exists",
"CategoryTheory.Retract",
"Iff",
"Nonempty",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.ObjectProperty",
"CategoryTheory.Category",
"CategoryTheory.ObjectProperty.retractClosure"
] | true |
_private.Mathlib.AlgebraicGeometry.Morphisms.Basic.0.AlgebraicGeometry.HasAffineProperty.iff.match_1_1 | Mathlib.AlgebraicGeometry.Morphisms.Basic | [
"CategoryTheory.MorphismProperty",
"AlgebraicGeometry.IsZariskiLocalAtTarget",
"AlgebraicGeometry.Scheme",
"AlgebraicGeometry.AffineTargetMorphismProperty.of",
"And.casesOn",
"And",
"And.intro",
"AlgebraicGeometry.AffineTargetMorphismProperty",
"CategoryTheory.Category.toCategoryStruct",
"Algebrai... | false |
Irreducible.isRoot_eq_bot_of_natDegree_ne_one | Mathlib.Algebra.Polynomial.Div | [
"le_bot_iff",
"IsDomain",
"CommRing",
"CommSemiring.toSemiring",
"Polynomial.IsRoot",
"OrderBot.toBot",
"Prop.le",
"PartialOrder.toPreorder",
"Prop.instHeytingAlgebra",
"Preorder.toLE",
"Irreducible",
"Pi.instOrderBot",
"Pi.instBotForall",
"Ne",
"instOfNatNat",
"Bot.bot",
"LE.le",
... | true |
BitVec.clz_lt_iff_ne_zero | Init.Data.BitVec.Lemmas | [
"False",
"eq_false",
"iff_false",
"congrArg",
"BitVec.lt_of_le_ne",
"BitVec",
"Eq.mp",
"Ne",
"instOfNatNat",
"BitVec.clz_eq_iff_eq_zero",
"LE.le",
"BitVec.ofNat",
"false_iff",
"Nat.cast",
"Iff",
"instLTBitVec",
"Nat",
"LT.lt",
"True",
"Iff.intro",
"of_eq_true",
"instLEBitVe... | true |
Commute.invOf_left | Mathlib.Algebra.Group.Invertible.Basic | [
"Monoid",
"Eq.mpr",
"MulOne.toOne",
"Semigroup.toMul",
"Trans.trans",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"mul_assoc",
"Invertible.invOf",
"Commute",
"id",
"MulOne.toMul",
"instTransEq",
"MulOneClass.toMulOne",
"invOf_mul_cancel_left'",
"True",
"eq_self",
"Monoid.toS... | true |
Option.get_congr | Init.Data.Option.Lemmas | [
"HEq.refl",
"Eq.rec",
"Eq.casesOn",
"Bool.true",
"Option.get",
"Bool",
"eq_of_heq",
"Eq.ndrec",
"Eq.refl",
"HEq",
"Option.isSome",
"Eq.symm",
"Eq",
"Option"
] | true |
Lean.Expr.rat? | Mathlib.Lean.Expr.Rat | [
"guard",
"Pure.pure",
"Int.cast",
"instDecidableNot",
"instAlternativeOption",
"Lean.Expr.isAppOfArity",
"Monad.toApplicative",
"Rat",
"Lean.Expr.appArg!",
"Rat.den",
"Rat.instIntCast",
"Lean.Expr",
"instDecidableEqBool",
"Ne",
"instOfNatNat",
"Int",
"Applicative.toPure",
"instMona... | true |
Units.instDiv.eq_1 | Mathlib.Algebra.Group.Units.Defs | [
"Monoid",
"Units.val",
"HMul.hMul",
"Monoid.toMulOneClass",
"Units.instDiv",
"Units",
"MulOne.toMul",
"Div",
"Div.mk",
"MulOneClass.toMulOne",
"Inv.inv",
"Units.instDiv._proof_2",
"Units.mk",
"Eq.refl",
"Units.instDiv._proof_1",
"Eq",
"Units.instInv",
"instHMul"
] | true |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.visitType._unsafe_rec | Lean.Meta.LetToHave | [
"_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.visit._unsafe_rec",
"_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.Context",
"_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.M",
"ReaderT.instMonad",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"_private.Lean.Meta.LetToHave.0.Lean.Meta.L... | false |
instMonadLiftT | Init.Prelude | [
"MonadLiftT",
"MonadLiftT.mk"
] | true |
Std.ExtHashMap.unitOfList_eq_empty_iff._simp_1 | Std.Data.ExtHashMap.Lemmas | [
"Std.ExtHashMap.unitOfList",
"LawfulHashable",
"Std.ExtHashMap",
"Std.ExtHashMap.instEmptyCollection",
"List",
"Unit",
"EquivBEq",
"Std.ExtHashMap.unitOfList_eq_empty_iff",
"propext",
"Hashable",
"EmptyCollection.emptyCollection",
"BEq",
"Eq",
"List.nil"
] | false |
Orientation.kahler._proof_5 | Mathlib.Analysis.InnerProductSpace.TwoDim | [
"instInnerProductSpaceRealComplex",
"InnerProductSpace.toNormedSpace",
"NormedCommRing.toSeminormedCommRing",
"Real",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Real.instRCLike",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"NormedSpace.toModule",
"AddMonoid.toAddZeroClass",... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.