name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.Order.Compare.0.Ordering.Compares.le_total.match_1_1 | Mathlib.Order.Compare | ∀ {α : Type u_1} [inst : Preorder α] {a b : α} (motive : (x : Ordering) → x.Compares a b → Prop) (x : Ordering)
(x_1 : x.Compares a b),
(∀ (h : Ordering.lt.Compares a b), motive Ordering.lt h) →
(∀ (h : Ordering.eq.Compares a b), motive Ordering.eq h) →
(∀ (h : Ordering.gt.Compares a b), motive Ordering.g... | false |
_private.Mathlib.Data.Real.Basic.0.Real.mk_mul._simp_1_2 | Mathlib.Data.Real.Basic | ∀ (a b : CauSeq.Completion.Cauchy abs), { cauchy := a } * { cauchy := b } = { cauchy := a * b } | false |
Fin.preimage_rev_Icc | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} (i j : Fin n), Fin.rev ⁻¹' Set.Icc i j = Set.Icc j.rev i.rev | true |
CategoryTheory.Limits.reflectsLimit_of_natIso | Mathlib.CategoryTheory.Limits.Preserves.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : Type w} [inst_2 : CategoryTheory.Category.{w', w} J] (K : CategoryTheory.Functor J C)
{F G : CategoryTheory.Functor C D} (h : F ≅ G) [CategoryTheory.Limits.ReflectsLimit K F],
CategoryTheor... | true |
BitVec.cons_induction | Init.Data.BitVec.Bootstrap | ∀ {motive : (w : ℕ) → BitVec w → Prop},
motive 0 BitVec.nil →
(∀ {w : ℕ} (b : Bool) (bv : BitVec w), motive w bv → motive (w + 1) (BitVec.cons b bv)) →
∀ {w : ℕ} (x : BitVec w), motive w x | true |
instHasExactLimitsOfShapeDiscreteAddCommGrpCat | Mathlib.Algebra.Category.Grp.AB | ∀ {J : Type u}, CategoryTheory.HasExactLimitsOfShape (CategoryTheory.Discrete J) AddCommGrpCat | true |
_private.Mathlib.Topology.Algebra.Category.ProfiniteGrp.Limits.0.ProfiniteGrp.toLimitFun_continuous._simp_1_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Limits | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | false |
Lean.Meta.Grind.Arith.CommRing.Semiring.mk.injEq | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | ∀ (id : ℕ) (type : Lean.Expr) (u : Lean.Level) (semiringInst : Lean.Expr)
(addFn? mulFn? powFn? natCastFn? : Option Lean.Expr)
(denote : Lean.PHashMap Lean.Meta.Sym.ExprPtr Lean.Meta.Grind.Arith.CommRing.SemiringExpr)
(vars : Lean.PArray Lean.Expr) (varMap : Lean.PHashMap Lean.Meta.Sym.ExprPtr Lean.Grind.CommRing... | true |
IsOpen.ae_eq_zero_of_integral_smooth_smul_eq_zero' | Mathlib.Analysis.Distribution.AEEqOfIntegralContDiff | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [FiniteDimensional ℝ E] {F : Type u_2}
[inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] [CompleteSpace F] {H : Type u_3}
[inst_6 : TopologicalSpace H] (I : ModelWithCorners ℝ E H) {M : Type u_4} [inst_7 : TopologicalSpace M]
[inst... | true |
CategoryTheory.Limits.hasColimit_unop_of_hasLimit | Mathlib.CategoryTheory.Limits.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} J]
(F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ) [CategoryTheory.Limits.HasLimit F], CategoryTheory.Limits.HasColimit F.unop | true |
Lean.Grind.AddCommGroup.neg_sub | Init.Grind.Module.Basic | ∀ {M : Type u} [inst : Lean.Grind.AddCommGroup M] (a b : M), -(a - b) = b - a | true |
OreLocalization.add_smul | Mathlib.RingTheory.OreLocalization.Ring | ∀ {R : Type u_1} [inst : Semiring R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {X : Type u_2}
[inst_2 : AddCommMonoid X] [inst_3 : Module R X] (y z : OreLocalization S R) (x : OreLocalization S X),
(y + z) • x = y • x + z • x | true |
Dense.ciSup | Mathlib.Topology.Order.IsLUB | ∀ {γ : Type u_2} {α : Type u_3} [inst : TopologicalSpace α] [inst_1 : ConditionallyCompleteLattice α]
[ClosedIicTopology α] {f : γ → α} [inst_3 : TopologicalSpace γ] {S : Set γ},
Dense S → Continuous f → BddAbove (Set.range f) → ⨆ s, f ↑s = ⨆ i, f i | true |
Polynomial.instCharP | Mathlib.RingTheory.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (p : ℕ) [h : CharP R p], CharP (Polynomial R) p | true |
String.Slice.find?_char_eq_find?_beq | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice}, s.find? c = s.find? fun x => x == c | true |
Part.Fix.exists_fix_le_approx | Mathlib.Control.LawfulFix | ∀ {α : Type u_1} {β : α → Type u_2} (f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)) (x : α),
∃ i, Part.fix (⇑f) x ≤ Part.Fix.approx (⇑f) i x | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_171 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α)
(h : List.idxOfNth w [g (g a)] 1 + 1 ≤ (List.filter (fun x => decide (x = w)) [g (g a)]).length),
(List.findIdxs (fun x => decide (x = w)) [g (g a)])[List.idxOfNth w [g (g a)] 1] < [g (g a)].length | false |
CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject.recOn | Mathlib.CategoryTheory.Monoidal.Free.Coherence | {C : Type u} →
{motive : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C → Sort u_1} →
(t : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C) →
motive CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject.unit →
((a : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C... | false |
Submodule.smithNormalForm._proof_4 | Mathlib.LinearAlgebra.FreeModule.PID | ∀ {R : Type u_1} [inst : CommRing R] [IsDomain R], InvariantBasisNumber R | false |
MeasureTheory.integrableOn_singleton._auto_1 | Mathlib.MeasureTheory.Integral.IntegrableOn | Lean.Syntax | false |
Lean.Server.ILeanMap | Lean.Server.References | Type | true |
RatFunc.aeval_X_left_eq_algebraMap | Mathlib.FieldTheory.RatFunc.AsPolynomial | ∀ {K : Type u} [inst : CommRing K] [inst_1 : IsDomain K] (p : Polynomial K),
(Polynomial.aeval RatFunc.X) p = (algebraMap (Polynomial K) (RatFunc K)) p | true |
ContinuousLinearMap.inCoordinates.congr_simp | Mathlib.Topology.VectorBundle.Basic | ∀ {B : Type u_2} (F : Type u_3) (E : B → Type u_4) [inst : (x : B) → AddCommMonoid (E x)]
[inst_1 : NormedAddCommGroup F] [inst_2 : TopologicalSpace B] [inst_3 : (x : B) → TopologicalSpace (E x)]
{𝕜₁ : Type u_5} {𝕜₂ : Type u_6} [inst_4 : NontriviallyNormedField 𝕜₁] [inst_5 : NontriviallyNormedField 𝕜₂]
{σ : �... | true |
Computation.map_congr | Mathlib.Data.Seq.Computation | ∀ {α : Type u} {β : Type v} {s1 s2 : Computation α} {f : α → β},
s1.Equiv s2 → (Computation.map f s1).Equiv (Computation.map f s2) | true |
Std.IterM.DefaultConsumers.forIn'.wf._unary._proof_1 | Init.Data.Iterators.Consumers.Monadic.Loop | ∀ {m : Type u_1 → Type u_3} {α β : Type u_1} [inst : Std.Iterator α m β] (γ : Type u_2)
(PlausibleForInStep : β → γ → ForInStep γ → Prop) (wf : Std.IteratorLoop.WellFounded α m PlausibleForInStep)
(P : β → Prop),
WellFounded
(invImage (fun x => PSigma.casesOn x fun it init => PSigma.casesOn init fun init hP =... | false |
ConvexBody.hausdorffEdist_coe | Mathlib.Analysis.Convex.Body | ∀ {V : Type u_1} [inst : SeminormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] (K L : ConvexBody V),
Metric.hausdorffEDist ↑K ↑L = edist K L | true |
ENNReal.sInf_add | Mathlib.Data.ENNReal.Operations | ∀ {a : ENNReal} {s : Set ENNReal}, sInf s + a = ⨅ b ∈ s, b + a | true |
CategoryTheory.Kleisli.Hom.mk.inj | Mathlib.CategoryTheory.Monad.Kleisli | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {T : CategoryTheory.Monad C} {c c' : CategoryTheory.Kleisli T}
{of of_1 : c.of ⟶ T.obj c'.of}, { of := of } = { of := of_1 } → of = of_1 | true |
PresheafOfModules.instMonoidalCompOppositeCommRingCatRingCatForget₂RingHomCarrierCarrierOpPushforward₀OfCommRingCat._proof_6 | Mathlib.Algebra.Category.ModuleCat.Presheaf.PushforwardZeroMonoidal | ∀ {C : Type u_2} {D : Type u_5} [inst : CategoryTheory.Category.{u_3, u_2} C]
[inst_1 : CategoryTheory.Category.{u_4, u_5} D] (F : CategoryTheory.Functor C D)
(R : CategoryTheory.Functor Dᵒᵖ CommRingCat)
(x : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))),
(CategoryTheory.MonoidalCateg... | false |
Lean.Lsp.Range.mk.injEq | Lean.Data.Lsp.BasicAux | ∀ (start «end» start_1 end_1 : Lean.Lsp.Position),
({ start := start, «end» := «end» } = { start := start_1, «end» := end_1 }) = (start = start_1 ∧ «end» = end_1) | true |
Lean.Parser.ModuleParserState.mk.sizeOf_spec | Lean.Parser.Module | ∀ (pos : String.Pos.Raw) (recovering hasLeading : Bool),
sizeOf { pos := pos, recovering := recovering, hasLeading := hasLeading } =
1 + sizeOf pos + sizeOf recovering + sizeOf hasLeading | true |
Aesop.RuleApplication.casesOn | Aesop.RuleTac.Basic | {motive : Aesop.RuleApplication → Sort u} →
(t : Aesop.RuleApplication) →
((goals : Array Aesop.Subgoal) →
(postState : Lean.Meta.SavedState) →
(scriptSteps? : Option (Array Aesop.Script.LazyStep)) →
(successProbability? : Option Aesop.Percent) →
motive
... | false |
_private.Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn.0.MeasureTheory.SignedMeasure.restrictNonposSeq_measurableSet | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn | ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : MeasureTheory.SignedMeasure α} {i : Set α} (n : ℕ),
MeasurableSet (MeasureTheory.SignedMeasure.restrictNonposSeq✝ s i n) | true |
Std.PRange.Least?.rec | Init.Data.Range.Polymorphic.UpwardEnumerable | {α : Type u} →
{motive : Std.PRange.Least? α → Sort u_1} →
((least? : Option α) → motive { least? := least? }) → (t : Std.PRange.Least? α) → motive t | false |
Lean.HasConstCache._sizeOf_1 | Lean.Util.HasConstCache | {declNames : Array Lean.Name} → Lean.HasConstCache declNames → ℕ | false |
_private.Mathlib.Order.Bounds.Basic.0.lowerBounds_le_upperBounds_of_nonempty_inter.match_1_1 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} {s s' : Set α} (motive : (s ∩ s').Nonempty → Prop) (h : (s ∩ s').Nonempty),
(∀ (x : α) (hx : x ∈ s) (hx' : x ∈ s'), motive ⋯) → motive h | false |
_private.Init.Data.String.Pattern.Basic.0.String.Slice.Pattern.Internal.memcmpSlice._proof_1 | Init.Data.String.Pattern.Basic | ∀ (lhs rhs : String.Slice) (lstart rstart len : String.Pos.Raw),
len.offsetBy lstart ≤ lhs.rawEndPos → len.offsetBy (lstart.offsetBy lhs.startInclusive.offset) ≤ lhs.str.rawEndPos | false |
AddGroupSeminorm.toSeminormedAddGroup._proof_3 | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_1} [inst : AddGroup E] (f : AddGroupSeminorm E) (x x_1 : E), f (-x + x_1) = f (-x + x_1) | false |
SimplexCategory.rev_map_σ | Mathlib.AlgebraicTopology.SimplexCategory.Rev | ∀ {n : ℕ} (i : Fin (n + 1)), SimplexCategory.rev.map (SimplexCategory.σ i) = SimplexCategory.σ i.rev | true |
BitVec.getElem_concat_succ | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {b : Bool} {x : BitVec w} {i : ℕ} (h : i + 1 < w + 1), (x.concat b)[i + 1] = x[i] | true |
IsTrans.recOn | Mathlib.Order.Defs.Unbundled | {α : Sort u_1} →
{r : α → α → Prop} →
{motive : IsTrans α r → Sort u} →
(t : IsTrans α r) → ((trans : ∀ (a b c : α), r a b → r b c → r a c) → motive ⋯) → motive t | false |
CategoryTheory.Functor.toPseudofunctor'_mapComp | Mathlib.CategoryTheory.Bicategory.Functor.LocallyDiscrete | ∀ {I : Type u_1} {B : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} I] [inst_1 : CategoryTheory.Bicategory B]
[inst_2 : CategoryTheory.Bicategory.Strict B] (F : CategoryTheory.Functor I B)
{a b c : CategoryTheory.LocallyDiscrete I} (f : a ⟶ b) (g : b ⟶ c),
F.toPseudofunctor'.mapComp f g = CategoryTheory.eq... | true |
tensorKaehlerQuotKerSqEquiv._proof_16 | Mathlib.RingTheory.Smooth.Kaehler | ∀ (R : Type u_3) (P : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra P S],
IsScalarTower P S (TensorProduct (P ⧸ RingHom.ker (algebraMap P S) ^ 2) S Ω[P ⧸ RingHom.ker (algebraMap P S) ^ 2⁄R]) | false |
_private.Lean.Elab.Command.0.Lean.Elab.Command.mkInfoTree | Lean.Elab.Command | Lean.Name → Lean.Syntax → Lean.PersistentArray Lean.Elab.InfoTree → Lean.Elab.Command.CommandElabM Lean.Elab.InfoTree | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction.0._proof_12 | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | { len := 1 }.len ≤ 2 | false |
CategoryTheory.Functor.OneHypercoverDenseData.isSheaf_iff.liftAux | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u₀} →
{C : Type u} →
[inst : CategoryTheory.Category.{v₀, u₀} C₀] →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C₀ C} →
{J₀ : CategoryTheory.GrothendieckTopology C₀} →
{J : CategoryTheory.GrothendieckTopology C} →
{A : Type... | true |
Nat.eq_one_of_mul_eq_one_right | Init.Data.Nat.Lemmas | ∀ {m n : ℕ}, m * n = 1 → m = 1 | true |
CategoryTheory.Injective.mk | Mathlib.CategoryTheory.Preadditive.Injective.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : C},
(∀ {X Y : C} (g : X ⟶ J) (f : X ⟶ Y) [CategoryTheory.Mono f], ∃ h, CategoryTheory.CategoryStruct.comp f h = g) →
CategoryTheory.Injective J | true |
Set.isScalarTower'' | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : SMul α β] [inst_1 : SMul α γ] [inst_2 : SMul β γ]
[IsScalarTower α β γ], IsScalarTower (Set α) (Set β) (Set γ) | true |
Subfield.isTotallyReal_bot | Mathlib.NumberTheory.NumberField.InfinitePlace.TotallyRealComplex | ∀ (K : Type u_2) [inst : Field K] [CharZero K], NumberField.IsTotallyReal ↥⊥ | true |
_private.Mathlib.GroupTheory.Perm.Centralizer.0.Equiv.Perm.card_of_cycleType_singleton._proof_1_1 | Mathlib.GroupTheory.Perm.Centralizer | ∀ {n : ℕ}, 2 ≤ n → ¬n = 0 | false |
HNNExtension.lift | Mathlib.GroupTheory.HNNExtension | {G : Type u_1} →
[inst : Group G] →
{A B : Subgroup G} →
{φ : ↥A ≃* ↥B} →
{H : Type u_2} →
[inst_1 : Group H] →
(f : G →* H) → (x : H) → (∀ (a : ↥A), x * f ↑a = f ↑(φ a) * x) → HNNExtension G A B φ →* H | true |
DirectLimit.instGroupWithZero._proof_18 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] {G : ι → Type u_1} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [Nonempty ι]
[inst_5 : (i : ι) → ... | false |
CategoryTheory.kernelCokernelCompSequence.isColimit._simp_1 | Mathlib.CategoryTheory.Abelian.DiagramLemmas.KernelCokernelComp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
[inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] {Z : C} {f g : X ⊞ Y ⟶ Z},
(f = g) =
(CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.biprod.inl f =
CategoryTheory.CategoryStruct.c... | false |
Fin.preimage_natAdd_Ioi_natAdd | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} (m : ℕ) (i : Fin n), Fin.natAdd m ⁻¹' Set.Ioi (Fin.natAdd m i) = Set.Ioi i | true |
CategoryTheory.ChosenPullbacksAlong.pullbackCone | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{Y Z X : C} →
(f : Y ⟶ X) → (g : Z ⟶ X) → [CategoryTheory.ChosenPullbacksAlong g] → CategoryTheory.Limits.PullbackCone f g | true |
mem_leftCoset | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Mul α] {s : Set α} {x : α} (a : α), x ∈ s → a * x ∈ a • s | true |
Lean.Meta.Grind.Arith.Cutsat.isMul? | Lean.Meta.Tactic.Grind.Arith.Cutsat.Var | Lean.Expr → optParam Bool true → Lean.Meta.Grind.GoalM (Option (ℤ × Lean.Expr)) | true |
CategoryTheory.Limits.HasLimitsOfSize.has_limits_of_shape._autoParam | Mathlib.CategoryTheory.Limits.HasLimits | Lean.Syntax | false |
CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.isNormalEpiCategory | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasKernels C] [inst_3 : CategoryTheory.Limits.HasCokernels C]
[∀ {X Y : C} (f : X ⟶ Y), CategoryTheory.IsIso (CategoryTheory.Abelian.coimageImageComparison f)]
[CategoryTheory.Limits.Ha... | true |
Lean.Meta.GeneralizeArg._sizeOf_inst | Lean.Meta.Tactic.Generalize | SizeOf Lean.Meta.GeneralizeArg | false |
codisjoint_himp_self_left | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} {x y : α} [inst : BooleanAlgebra α], Codisjoint (x ⇨ y) x | true |
_private.Lean.Compiler.LCNF.ToImpure.0.Lean.Compiler.LCNF.Code.toImpure.match_1 | Lean.Compiler.LCNF.ToImpure | (motive : Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure × Bool → Sort u_1) →
(x : Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure × Bool) →
((p : Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure) → (keep : Bool) → motive (p, keep)) → motive x | false |
Preord | Mathlib.Order.Category.Preord | Type (u_1 + 1) | true |
DifferentiableAt.fun_add_iff_left | 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}
{x : E}, DifferentiableAt 𝕜 g x → (DifferentiableAt 𝕜 (fun i => f i + g i) x ↔ DifferentiableAt ... | true |
Lean.Elab.Tactic.Grind.replaceMainGoal | Lean.Elab.Tactic.Grind.Basic | List Lean.Meta.Grind.Goal → Lean.Elab.Tactic.Grind.GrindTacticM Unit | true |
Lean.PersistentArray.toList | Lean.Data.PersistentArray | {α : Type u} → Lean.PersistentArray α → List α | true |
IsAlgClosed.roots_eq_zero_iff_degree_nonpos | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ {k : Type u} [inst : Field k] [IsAlgClosed k] {p : Polynomial k}, p.roots = 0 ↔ p.degree ≤ 0 | true |
MonoidAlgebra.map_one | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {S : Type u_4} {M : Type u_6} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Monoid M]
(f : R →+* S), MonoidAlgebra.map (↑f) 1 = 1 | true |
PMF.mem_support_ofFintype_iff | Mathlib.Probability.ProbabilityMassFunction.Constructions | ∀ {α : Type u_1} [inst : Fintype α] {f : α → ENNReal} (h : ∑ a, f a = 1) (a : α),
a ∈ (PMF.ofFintype f h).support ↔ f a ≠ 0 | true |
_private.Mathlib.RingTheory.Polynomial.GaussNorm.0.Polynomial.aux_bdd._simp_1_4 | Mathlib.RingTheory.Polynomial.GaussNorm | ∀ {R : Type u} {n : ℕ} [inst : Semiring R] {p : Polynomial R}, (n ∈ p.support) = (p.coeff n ≠ 0) | false |
_private.Lean.Elab.App.0.Lean.Elab.Term.ensureArgType | Lean.Elab.App | Lean.Expr → Lean.Expr → Lean.Expr → Lean.Elab.TermElabM Lean.Expr | true |
CharZero.neg_eq_self_iff | Mathlib.Algebra.Ring.CharZero | ∀ {R : Type u_2} [inst : NonAssocRing R] [NoZeroDivisors R] [CharZero R] {a : R}, -a = a ↔ a = 0 | true |
AddMonoidWithOne.binary._proof_3 | Mathlib.Data.Nat.Cast.Defs | ∀ {R : Type u_1} [inst : AddMonoid R] [inst_1 : One R], Nat.binCast 0 = 0 | false |
ContinuousLinearEquiv._sizeOf_1 | Mathlib.Topology.Algebra.Module.Equiv | {R : Type u_1} →
{S : Type u_2} →
{inst : Semiring R} →
{inst_1 : Semiring S} →
{σ : R →+* S} →
{σ' : S →+* R} →
{inst_2 : RingHomInvPair σ σ'} →
{inst_3 : RingHomInvPair σ' σ} →
{M : Type u_3} →
{inst_4 : TopologicalSpace M} →
... | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get_union_of_contains_eq_false_left._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
Finpartition.ofPairwiseDisjoint._proof_2 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : OrderBot α] [inst_2 : DecidableEq α] (parts : Finset α),
(parts.erase ⊥).sup id = parts.sup id | false |
Array.Matcher.state._default | Batteries.Data.Array.Match | {α : Type u_1} → (table : Array.PrefixTable α) → Fin (table.size + 1) | false |
Std.PRange.instPreservesLTOfLawfulOrderLTOfPreservesLE | Init.Data.Range.Polymorphic.Map | ∀ {α : Type u_1} {β : Type u_2} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.UpwardEnumerable β]
[inst_2 : LE α] [inst_3 : LT α] [Std.LawfulOrderLT α] [inst_5 : LE β] [inst_6 : LT β] [Std.LawfulOrderLT β]
(f : Std.PRange.UpwardEnumerable.Map α β) [f.PreservesLE], f.PreservesLT | true |
Prod.instAddCommMonoid.eq_1 | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N],
Prod.instAddCommMonoid = { toAddMonoid := Prod.instAddMonoid, add_comm := ⋯ } | true |
_private.Init.Data.List.Zip.0.List.zipWith_eq_append_iff._simp_1_1 | Init.Data.List.Zip | ∀ {α : Type u_1} {xs : List α}, ([] = xs) = (xs = []) | false |
PowerSeries.coeff_subst_finite | Mathlib.RingTheory.PowerSeries.Substitution | ∀ {R : Type u_2} [inst : CommRing R] {τ : Type u_3} {S : Type u_4} [inst_1 : CommRing S] [inst_2 : Algebra R S]
{a : MvPowerSeries τ S},
PowerSeries.HasSubst a →
∀ (f : PowerSeries R) (e : τ →₀ ℕ),
Function.HasFiniteSupport fun d => (PowerSeries.coeff d) f • (MvPowerSeries.coeff e) (a ^ d) | true |
Real.logb_pos | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {b x : ℝ}, 1 < b → 1 < x → 0 < Real.logb b x | true |
Equiv.neg.eq_1 | Mathlib.Algebra.Group.Equiv.Basic | ∀ (G : Type u_14) [inst : InvolutiveNeg G], Equiv.neg G = Function.Involutive.toPerm Neg.neg ⋯ | true |
InnerProductGeometry.angle_zero_right | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] (x : V),
InnerProductGeometry.angle x 0 = Real.pi / 2 | true |
Std.DTreeMap.Internal.Impl.Const.minEntryD._unary.eq_def | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u} {β : Type v} (_x : (_ : Std.DTreeMap.Internal.Impl α fun x => β) ×' α × β),
Std.DTreeMap.Internal.Impl.Const.minEntryD._unary _x =
PSigma.casesOn _x fun a a_1 =>
match a, a_1 with
| Std.DTreeMap.Internal.Impl.leaf, fallback => fallback
| Std.DTreeMap.Internal.Impl.inner size k v S... | false |
IsDedekindDomain.instCommRingFiniteAdeleRing._proof_19 | Mathlib.RingTheory.DedekindDomain.FiniteAdeleRing | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_2) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (a b c : IsDedekindDomain.FiniteAdeleRing R K),
a * b * c = a * (b * c) | false |
instAddCommMonoidWeakBilin._aux_1 | Mathlib.Topology.Algebra.Module.Spaces.WeakBilin | {𝕜 : Type u_2} →
{E : Type u_1} →
{F : Type u_3} →
[inst : CommSemiring 𝕜] →
[inst_1 : AddCommMonoid E] →
[inst_2 : Module 𝕜 E] →
[inst_3 : AddCommMonoid F] → [inst_4 : Module 𝕜 F] → (x : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) → AddCommMonoid (WeakBilin x) | false |
PeriodPair.lattice_eq_span_range_basis | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ (L : PeriodPair), L.lattice = Submodule.span ℤ (Set.range ⇑L.basis) | true |
ContinuousLinearEquiv.smulLeft._proof_2 | Mathlib.Topology.Algebra.Module.Equiv | ∀ {M₁ : Type u_1} [inst : TopologicalSpace M₁] [inst_1 : AddCommMonoid M₁] {G : Type u_2} [inst_2 : Group G]
[inst_3 : DistribMulAction G M₁] [ContinuousConstSMul G M₁] (g : G), Continuous fun x => g⁻¹ • x | false |
Filter.Germ.const_le_iff | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} [inst : LE β] [l.NeBot] {x y : β}, ↑x ≤ ↑y ↔ x ≤ y | true |
String.Slice.Pos.mk._flat_ctor | Init.Data.String.Defs | {s : String.Slice} → (offset : String.Pos.Raw) → String.Pos.Raw.IsValidForSlice s offset → s.Pos | false |
Lean.Meta.getCongrSimpKindsForArgZero | Lean.Meta.CongrTheorems | Lean.Meta.FunInfo → Lean.MetaM (Array Lean.Meta.CongrArgKind) | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Horn.0.SSet.subcomplex_le_horn_iff._proof_1_3 | Mathlib.AlgebraicTopology.SimplicialSet.Horn | ∀ {n : ℕ} (d : ℕ), n ≤ d → ∀ (S : Finset (Fin (n + 1 + 1))), S.card = d + 1 → n < d → n + 1 + 1 ≤ S.card | false |
NormedAddGroup.uniformity_basis_dist | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedAddGroup E], (uniformity E).HasBasis (fun ε => 0 < ε) fun ε => {p | ‖-p.1 + p.2‖ < ε} | true |
Lean.Elab.Command.InductiveView.mk._flat_ctor | Lean.Elab.MutualInductive | Lean.Syntax →
Lean.Syntax →
Lean.Elab.Modifiers →
Bool →
Bool →
Bool →
Lean.Name →
Lean.Name →
List Lean.Name →
Lean.Syntax →
Option Lean.Syntax →
Array Lean.Elab.Command.CtorView →
... | false |
Std.TreeMap.getKey_maxKey | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp]
{he : t.isEmpty = false} {hc : t.maxKey he ∈ t}, t.getKey (t.maxKey he) hc = t.maxKey he | true |
Stream'.WSeq.updateNth.match_1 | Mathlib.Data.WSeq.Defs | {α : Type u_1} →
(motive : Option (Stream'.Seq1 (Option α)) → ℕ → Sort u_2) →
(x : Option (Stream'.Seq1 (Option α))) →
(n : ℕ) →
((x : ℕ) → motive none x) →
((s' : Stream'.Seq (Option α)) → (n : ℕ) → motive (some (none, s')) n) →
((a' : α) → (s' : Stream'.Seq (Option α)) → moti... | false |
Std.HashMap.size_inter_le_size_right | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α],
(m₁ ∩ m₂).size ≤ m₂.size | true |
CategoryTheory.Limits.IsImage.mk | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : X ⟶ Y} →
{F : CategoryTheory.Limits.MonoFactorisation f} →
(lift : (F' : CategoryTheory.Limits.MonoFactorisation f) → F.I ⟶ F'.I) →
autoParam
(∀ (F' : CategoryTheory.Limits.MonoFactorisa... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.