name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
ExistsContDiffBumpBase.y | Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] → [FiniteDimensional ℝ E] → [inst_3 : MeasurableSpace E] → [BorelSpace E] → ℝ → E → ℝ | true |
Finset.mem_map'._simp_1 | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} (f : α ↪ β) {a : α} {s : Finset α}, (f a ∈ Finset.map f s) = (a ∈ s) | false |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear.0.RootPairing.rootFormIn_self_smul_coroot._simp_1_3 | Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (self : RootPairing ι R M N) (i j : ι),
self.coroot ((self.reflectionPerm i) j) =
self.coroot j - (self.toLinearMap (self.root i)) (se... | false |
CategoryTheory.Precoverage.RespectsIso | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.Precoverage C → Prop | true |
Complex.equivRealProdAddHom_symm_apply_re | Mathlib.Data.Complex.Basic | ∀ (p : ℝ × ℝ), (Complex.equivRealProdAddHom.symm p).re = p.1 | true |
List.dropPrefix?_eq_some_iff._unary | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] {s : List α} (_x : (_ : List α) ×' List α),
_x.1.dropPrefix? _x.2 = some s ↔ ∃ p', _x.1 = p' ++ s ∧ (p' == _x.2) = true | false |
_private.Mathlib.Order.Category.HeytAlg.0.HeytAlg.Hom.mk._flat_ctor | Mathlib.Order.Category.HeytAlg | {X Y : HeytAlg} → HeytingHom ↑X ↑Y → X.Hom Y | false |
_private.Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous.0.MvPolynomial.weightedTotalDegree'_eq_bot_iff._simp_1_2 | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] (f : β → α) (S : Finset β),
(S.sup f = ⊥) = ∀ s ∈ S, f s = ⊥ | false |
Sylow.normal_of_normalizer_normal | Mathlib.GroupTheory.Sylow | ∀ {G : Type u} [inst : Group G] {p : ℕ} [Fact (Nat.Prime p)] [Finite (Sylow p G)] (P : Sylow p G),
(Subgroup.normalizer ↑↑P).Normal → (↑P).Normal | true |
_private.Mathlib.RingTheory.MvPowerSeries.LexOrder.0.MvPowerSeries.coeff_ne_zero_of_lexOrder._simp_1_5 | Mathlib.RingTheory.MvPowerSeries.LexOrder | ∀ {α : Type u_3} {β : Type u_4} {S : Set α} {f : α ≃ β} {x : β}, (x ∈ ⇑f '' S) = (f.symm x ∈ S) | false |
BoxIntegral.Prepartition.splitMany_le_split | Mathlib.Analysis.BoxIntegral.Partition.Split | ∀ {ι : Type u_1} (I : BoxIntegral.Box ι) {s : Finset (ι × ℝ)} {p : ι × ℝ},
p ∈ s → BoxIntegral.Prepartition.splitMany I s ≤ BoxIntegral.Prepartition.split I p.1 p.2 | true |
UInt64.zero_add | Init.Data.UInt.Lemmas | ∀ (a : UInt64), 0 + a = a | true |
Submodule.one | Mathlib.Algebra.Algebra.Operations | {R : Type u} → [inst : Semiring R] → {A : Type v} → [inst_1 : Semiring A] → [inst_2 : Module R A] → One (Submodule R A) | true |
AlgebraicGeometry.instIsIsoSchemeCoprodComparisonOppositeCommRingCatSpec | Mathlib.AlgebraicGeometry.Limits | ∀ (R S : CommRingCatᵒᵖ), CategoryTheory.IsIso (CategoryTheory.Limits.coprodComparison AlgebraicGeometry.Scheme.Spec R S) | true |
LieRingModule.toEnd_apply_apply | Mathlib.Algebra.Lie.Basic | ∀ (L : Type v) (M : Type w) [inst : LieRing L] [inst_1 : AddCommGroup M] [inst_2 : LieRingModule L M] (x : L) (m : M),
((LieRingModule.toEnd L M) x) m = ⁅x, m⁆ | true |
Lean.CodeAction.FindTacticResult.tactic.elim | Lean.Server.CodeActions.Provider | {motive : Lean.CodeAction.FindTacticResult → Sort u} →
(t : Lean.CodeAction.FindTacticResult) →
t.ctorIdx = 0 → ((a : Lean.Syntax.Stack) → motive (Lean.CodeAction.FindTacticResult.tactic a)) → motive t | false |
Aesop.BaseRuleSetMember.normForwardRule.sizeOf_spec | Aesop.RuleSet.Member | ∀ (r₁ : Aesop.ForwardRule) (r₂ : Aesop.NormRule),
sizeOf (Aesop.BaseRuleSetMember.normForwardRule r₁ r₂) = 1 + sizeOf r₁ + sizeOf r₂ | true |
Complex.cpow_zero | Mathlib.Analysis.SpecialFunctions.Pow.Complex | ∀ (x : ℂ), x ^ 0 = 1 | true |
Polynomial.root_right_of_root_gcd | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} {k : Type y} [inst : Field R] [inst_1 : CommSemiring k] [inst_2 : DecidableEq R] {ϕ : R →+* k}
{f g : Polynomial R} {α : k}, Polynomial.eval₂ ϕ α (EuclideanDomain.gcd f g) = 0 → Polynomial.eval₂ ϕ α g = 0 | true |
Stream'.get_map | Mathlib.Data.Stream.Init | ∀ {α : Type u} {β : Type v} (f : α → β) (n : ℕ) (s : Stream' α), (Stream'.map f s).get n = f (s.get n) | true |
Subsingleton.intro._flat_ctor | Init.Core | ∀ {α : Sort u}, (∀ (a b : α), a = b) → Subsingleton α | false |
Char.toString_eq_singleton | Init.Data.Char.Lemmas | ∀ {c : Char}, c.toString = String.singleton c | true |
Ideal.ramificationIdx_eq_of_isGaloisGroup | Mathlib.NumberTheory.RamificationInertia.Galois | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] (p : Ideal A)
(P Q : Ideal B) [hPp : P.IsPrime] [hp : P.LiesOver p] [hQp : Q.IsPrime] [Q.LiesOver p] (G : Type u_3)
[inst_4 : Group G] [Finite G] [inst_6 : MulSemiringAction G B] [IsGaloisGroup G A B],
p.ramificationI... | true |
Lean.Elab.Tactic.Do.SpecAttr.SpecProof.noConfusion | Lean.Elab.Tactic.Do.Attr | {P : Sort u} →
{t t' : Lean.Elab.Tactic.Do.SpecAttr.SpecProof} →
t = t' → Lean.Elab.Tactic.Do.SpecAttr.SpecProof.noConfusionType P t t' | false |
Lean.Elab.Command.CoinductiveElabData.ref | Lean.Elab.Coinductive | Lean.Elab.Command.CoinductiveElabData → Lean.Syntax | true |
Lean.Lsp.Range.mk.sizeOf_spec | Lean.Data.Lsp.BasicAux | ∀ (start «end» : Lean.Lsp.Position), sizeOf { start := start, «end» := «end» } = 1 + sizeOf start + sizeOf «end» | true |
Monotone.mapsTo_Icc | Mathlib.Order.Interval.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} [inst : Preorder α] [inst_1 : Preorder β] {a b : α},
Monotone f → Set.MapsTo f (Set.Icc a b) (Set.Icc (f a) (f b)) | true |
Std.DTreeMap.Internal.Impl.Const.getEntryGE.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} [inst : Ord α] [inst_1 : Std.TransOrd α] (k : α)
(x_3 : Std.DTreeMap.Internal.Impl.leaf.Ordered)
(he : ∃ a ∈ Std.DTreeMap.Internal.Impl.leaf, (compare a k).isGE = true),
Std.DTreeMap.Internal.Impl.Const.getEntryGE k Std.DTreeMap.Internal.Impl.leaf x_3 he = ⋯.elim | true |
Std.Do.SPred.Tactic.instHasFrameAndOfSimpAnd_1 | Std.Do.SPred.DerivedLaws | ∀ {φ : Prop} (σs : List (Type u_1)) (P P' Q' PQ : Std.Do.SPred σs) [Std.Do.SPred.Tactic.HasFrame P' Q' φ]
[Std.Do.SPred.Tactic.SimpAnd P Q' PQ], Std.Do.SPred.Tactic.HasFrame spred(P ∧ P') PQ φ | true |
CategoryTheory.MorphismProperty.Comma.Hom.ctorIdx | Mathlib.CategoryTheory.MorphismProperty.Comma | {A : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} A} →
{B : Type u_2} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} B} →
{T : Type u_3} →
{inst_2 : CategoryTheory.Category.{v_3, u_3} T} →
{L : CategoryTheory.Functor A T} →
{R : CategoryTheory.Functor B ... | false |
CategoryTheory.SymmetricCategory.mk | Mathlib.CategoryTheory.Monoidal.Braided.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[toBraidedCategory : CategoryTheory.BraidedCategory C] →
autoParam
(∀ (X Y : C),
CategoryTheory.CategoryStruct.comp (β_ X Y).hom (β_ Y X).hom =
Category... | true |
AddSubgroup.forall_mem_sup | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {C : Type u_2} [inst : AddCommGroup C] {s t : AddSubgroup C} {P : C → Prop},
(∀ x ∈ s ⊔ t, P x) ↔ ∀ x₁ ∈ s, ∀ x₂ ∈ t, P (x₁ + x₂) | true |
Homotopy.noConfusion | Mathlib.Algebra.Homology.Homotopy | {P : Sort u_2} →
{ι : Type u_1} →
{V : Type u} →
{inst : CategoryTheory.Category.{v, u} V} →
{inst_1 : CategoryTheory.Preadditive V} →
{c : ComplexShape ι} →
{C D : HomologicalComplex V c} →
{f g : C ⟶ D} →
{t : Homotopy f g} →
{ι... | false |
MulAction.IsMinimal.rec | Mathlib.Dynamics.Minimal | {M : Type u_1} →
{α : Type u_2} →
[inst : Monoid M] →
[inst_1 : TopologicalSpace α] →
[inst_2 : MulAction M α] →
{motive : MulAction.IsMinimal M α → Sort u} →
((dense_orbit : ∀ (x : α), Dense (MulAction.orbit M x)) → motive ⋯) →
(t : MulAction.IsMinimal M α) → mot... | false |
Complex.equivRealProdLm_symm_apply_im | Mathlib.LinearAlgebra.Complex.Module | ∀ (a : ℝ × ℝ), (Complex.equivRealProdLm.symm a).im = a.2 | true |
Set.mem_ite_empty_right._simp_1 | Mathlib.Data.Set.Basic | ∀ {α : Type u} (p : Prop) [inst : Decidable p] (t : Set α) (x : α), (x ∈ if p then t else ∅) = (p ∧ x ∈ t) | false |
Function.Exact.of_ladder_linearEquiv_of_exact | Mathlib.Algebra.Exact | ∀ {R : Type u_1} {M : Type u_2} {M' : Type u_3} {N : Type u_4} {N' : Type u_5} {P : Type u_6} {P' : Type u_7}
[inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M'] [inst_3 : AddCommMonoid N]
[inst_4 : AddCommMonoid N'] [inst_5 : AddCommMonoid P] [inst_6 : AddCommMonoid P'] [inst_7 : Module R M]... | true |
MeasureTheory.Measure.MutuallySingular.measure_compl_nullSet | Mathlib.MeasureTheory.Measure.MutuallySingular | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} (h : μ.MutuallySingular ν), ν h.nullSetᶜ = 0 | true |
_private.Mathlib.Algebra.Homology.ExactSequenceFour.0.CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles_hom_fac._proof_11 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {n : ℕ}
{S : CategoryTheory.ComposableArrows C (n + 3)},
S.Exact →
∀ (k : ℕ) (hk : autoParam (k ≤ n) CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles_hom_fac._auto_1),
CategoryTheory.CategoryStruc... | false |
_private.Lean.Meta.Tactic.Grind.Arith.FieldNormNum.0.Lean.Meta.Grind.Arith.FieldNormNum.Context.noConfusion | Lean.Meta.Tactic.Grind.Arith.FieldNormNum | {P : Sort u} →
{t t' : Lean.Meta.Grind.Arith.FieldNormNum.Context✝} →
t = t' → Lean.Meta.Grind.Arith.FieldNormNum.Context.noConfusionType✝ P t t' | false |
MeasureTheory.SimpleFunc.lintegralₗ._proof_1 | Mathlib.MeasureTheory.Function.SimpleFunc | IsScalarTower ENNReal ENNReal ENNReal | false |
_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.Zipper.FinitenessRelation._simp_10 | Std.Data.DTreeMap.Internal.Zipper | ∀ (n : ℕ), (n < n + 1) = True | false |
CategoryTheory.Monad.instInhabitedAlgebra | Mathlib.CategoryTheory.Monad.Algebra | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] → (T : CategoryTheory.Monad C) → [Inhabited C] → Inhabited T.Algebra | true |
Std.Time.Month.instReprQuarter._aux_1 | Std.Time.Date.Unit.Month | Std.Time.Month.Quarter → ℕ → Std.Format | false |
Nat.prod_factorization_pow_eq_self | Mathlib.Data.Nat.Factorization.Defs | ∀ {n : ℕ}, n ≠ 0 → (n.factorization.prod fun x1 x2 => x1 ^ x2) = n | true |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.balance2_All._simp_1_2 | Batteries.Data.RBMap.WF | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | false |
Sym | Mathlib.Data.Sym.Basic | Type u_1 → ℕ → Type (max 0 u_1) | true |
Lean.Server.RefInfo.casesOn | Lean.Server.References | {motive : Lean.Server.RefInfo → Sort u} →
(t : Lean.Server.RefInfo) →
((definition : Option Lean.Server.Reference) →
(usages : Array Lean.Server.Reference) → motive { definition := definition, usages := usages }) →
motive t | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting.0.CategoryTheory.Limits.termI₃_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | Lean.ParserDescr | true |
RelSeries.step | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (self : RelSeries r) (i : Fin self.length),
(self.toFun i.castSucc, self.toFun i.succ) ∈ r | true |
Submonoid.pi_top | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {ι : Type u_4} {M : ι → Type u_5} [inst : (i : ι) → MulOneClass (M i)] (I : Set ι), (Submonoid.pi I fun i => ⊤) = ⊤ | true |
Equiv.Perm.ext | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {σ τ : Equiv.Perm α}, (∀ (x : α), σ x = τ x) → σ = τ | true |
Quaternion.normSq_le_zero._simp_1 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] {a : Quaternion R},
(Quaternion.normSq a ≤ 0) = (a = 0) | false |
Lean.Doc.DocHighlight._sizeOf_1 | Lean.Elab.DocString.Builtin | Lean.Doc.DocHighlight → ℕ | false |
Rat.natCast_le_cast._simp_1 | Mathlib.Data.Rat.Cast.Order | ∀ {K : Type u_5} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] {m : ℕ} {n : ℚ}, (↑m ≤ ↑n) = (↑m ≤ n) | false |
ONote._sizeOf_1 | Mathlib.SetTheory.Ordinal.Notation | ONote → ℕ | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.caching.unsafe_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof | {α : Type u_1} → α → UInt64 | true |
_private.Mathlib.FieldTheory.Separable.0.Polynomial.separable_of_subsingleton._simp_1_2 | Mathlib.FieldTheory.Separable | ∀ {α : Sort u_1} [Subsingleton α] (x y : α), (x = y) = True | false |
Fin.Value.mk.injEq | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | ∀ (n : ℕ) (value : Fin n) (n_1 : ℕ) (value_1 : Fin n_1),
({ n := n, value := value } = { n := n_1, value := value_1 }) = (n = n_1 ∧ value ≍ value_1) | true |
NonemptyFinLinOrd._sizeOf_1 | Mathlib.Order.Category.NonemptyFinLinOrd | NonemptyFinLinOrd → ℕ | false |
Equiv.vadd | Mathlib.Algebra.Group.TransferInstance | (M : Type u_1) → {α : Type u_2} → {β : Type u_3} → α ≃ β → [VAdd M β] → VAdd M α | true |
CategoryTheory.ShortComplex.homologyι_naturality | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology],
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.homologyMap φ) S₂.homologyι =
Ca... | true |
Lean.JsonRpc.MessageDirection.toCtorIdx | Lean.Data.JsonRpc | Lean.JsonRpc.MessageDirection → ℕ | false |
isCoprime_mul_units_right | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {u v : R},
IsUnit u → IsUnit v → ∀ (y z : R), IsCoprime (y * u) (z * v) ↔ IsCoprime y z | true |
Path.Homotopy.reflTransSymmAux_mem_I | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ (x : ↑unitInterval × ↑unitInterval), Path.Homotopy.reflTransSymmAux x ∈ unitInterval | true |
IsStrictOrder.toIsTrans | Mathlib.Order.Defs.Unbundled | ∀ {α : Sort u_1} {r : α → α → Prop} [self : IsStrictOrder α r], IsTrans α r | true |
_private.Mathlib.Analysis.Complex.Polynomial.GaussLucas.0.Polynomial.eq_centerMass_of_eval_derivative_eq_zero._simp_1_12 | Mathlib.Analysis.Complex.Polynomial.GaussLucas | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | false |
Set.powersetCard.addAction_faithful | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ {α : Type u_2} [inst : DecidableEq α] {G : Type u_3} [inst_1 : AddGroup G] [inst_2 : AddAction G α] {n : ℕ},
1 ≤ n → ↑n < ENat.card α → ∀ {g : G}, AddAction.toPerm g = 1 ↔ AddAction.toPerm g = 1 | true |
_private.Mathlib.RingTheory.MvPowerSeries.LinearTopology.0.MvPowerSeries.LinearTopology.isTopologicallyNilpotent_of_constantCoeff._simp_1_5 | Mathlib.RingTheory.MvPowerSeries.LinearTopology | ∀ {σ : Type u_1} {R : Type u_2} {S : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (n : σ →₀ ℕ)
(φ : MvPowerSeries σ R), f ((MvPowerSeries.coeff n) φ) = (MvPowerSeries.coeff n) ((MvPowerSeries.map f) φ) | false |
Set.mapsTo_id | Mathlib.Data.Set.Function | ∀ {α : Type u_1} (s : Set α), Set.MapsTo id s s | true |
AlgebraicGeometry.Scheme.Cover.ColimitGluingData.isColimitGluedCocone._proof_6 | Mathlib.AlgebraicGeometry.ColimitsOver | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [inst : P.IsStableUnderBaseChange]
[inst_1 : P.IsMultiplicative] {S : AlgebraicGeometry.Scheme} {J : Type u_5}
[inst_2 : CategoryTheory.Category.{u_4, u_5} J] {D : CategoryTheory.Functor J (P.Over ⊤ S)} {𝒰 : S.OpenCover}
[inst_3 : CategoryTheory.Ca... | false |
Std.Time.Week.Offset.toHours | Std.Time.Date.Unit.Week | Std.Time.Week.Offset → Std.Time.Hour.Offset | true |
CategoryTheory.Lax.LaxTrans.id | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] → (F : CategoryTheory.LaxFunctor B C) → CategoryTheory.Lax.LaxTrans F F | true |
Lean.Elab.Modifiers.mk | Lean.Elab.DeclModifiers | Lean.TSyntax `Lean.Parser.Command.declModifiers →
Option (Lean.TSyntax `Lean.Parser.Command.docComment × Bool) →
Lean.Elab.Visibility →
Bool → Lean.Elab.ComputeKind → Lean.Elab.RecKind → Bool → Array Lean.Elab.Attribute → Lean.Elab.Modifiers | true |
TensorProduct.leftHasSMul | Mathlib.LinearAlgebra.TensorProduct.Defs | {R : Type u_1} →
{R' : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : Monoid R'] →
{M : Type u_7} →
{N : Type u_8} →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid N] →
[inst_4 : DistribMulAction R' M] →
[inst_5 : Module R ... | true |
TestFunctionClass.noConfusionType | Mathlib.Analysis.Distribution.TestFunction | Sort u →
{B : Type u_6} →
{E : Type u_7} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
{Ω : TopologicalSpace.Opens E} →
{F : Type u_8} →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NormedSpace ℝ F] →
{n : ℕ∞} →
... | false |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.PreprocessKind.mvarsOutputParams.sizeOf_spec | Lean.Meta.SynthInstance | sizeOf Lean.Meta.PreprocessKind.mvarsOutputParams✝ = 1 | true |
CategoryTheory.ShortComplex.Homotopy.refl_h₁ | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂), (CategoryTheory.ShortComplex.Homotopy.refl φ).h₁ = 0 | true |
DirectLimit.instAddMonoid._proof_6 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {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 : (i : ι) → AddMonoid (G i)] [∀ (i j : ι) (h : i ≤ j), AddMonoidHomClass (T h) (G i) (G j)] (n : ℕ)
(x x_1 : ι) ... | false |
Asymptotics.IsLittleO.sub | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {F : Type u_4} {E' : Type u_6} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {g : α → F}
{l : Filter α} {f₁ f₂ : α → E'}, f₁ =o[l] g → f₂ =o[l] g → (fun x => f₁ x - f₂ x) =o[l] g | true |
Int.sub_lt_sub_right_iff._simp_1 | Init.Data.Int.Order | ∀ {a b c : ℤ}, (a - c < b - c) = (a < b) | false |
Lean.Grind.NoopConfig.noConfusionType | Init.Grind.Config | Sort u → Lean.Grind.NoopConfig → Lean.Grind.NoopConfig → Sort u | false |
_private.Lean.Compiler.LCNF.Simp.DefaultAlt.0.Lean.Compiler.LCNF.Simp.addDefaultAlt.match_7 | Lean.Compiler.LCNF.Simp.DefaultAlt | (motive : MProd (Array (Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.pure)) Bool → Sort u_1) →
(r : MProd (Array (Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.pure)) Bool) →
((altsNew : Array (Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.pure)) →
(first : Bool) → motive ⟨altsNew, first⟩) →
... | false |
_private.Lean.Meta.Tactic.Simp.Types.0.Lean.Meta.Simp.tryAutoCongrTheorem?._proof_1 | Lean.Meta.Tactic.Simp.Types | ∀ (__do_lift : Lean.Meta.FunInfo) (config : Lean.Meta.Simp.Config)
(r :
MProd (Subarray Lean.Meta.CongrArgKind)
(MProd (Array Lean.Meta.Simp.Result) (MProd (Array Lean.Expr) (MProd Bool (MProd Bool (MProd ℕ Bool)))))),
config.ground = true ∧ r.snd.snd.snd.snd.snd.fst < __do_lift.paramInfo.size →
r.snd... | false |
_private.Mathlib.Order.Defs.PartialOrder.0.le_antisymm_iff.match_1_1 | Mathlib.Order.Defs.PartialOrder | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α} (motive : a ≤ b ∧ b ≤ a → Prop) (x : a ≤ b ∧ b ≤ a),
(∀ (h1 : a ≤ b) (h2 : b ≤ a), motive ⋯) → motive x | false |
Digraph.toSimpleGraphStrict._proof_1 | Mathlib.Combinatorics.Digraph.Orientation | ∀ {V : Type u_1} (G : Digraph V) (x x_1 : V), x ≠ x_1 ∧ G.Adj x x_1 ∧ G.Adj x_1 x → x_1 ≠ x ∧ G.Adj x_1 x ∧ G.Adj x x_1 | false |
_private.Mathlib.AlgebraicGeometry.Morphisms.RingHomProperties.0.AlgebraicGeometry.affineLocally_iff_forall_isAffineOpen._simp_1_1 | Mathlib.AlgebraicGeometry.Morphisms.RingHomProperties | ∀ (P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop) {X Y : AlgebraicGeometry.Scheme}
(f : X ⟶ Y),
AlgebraicGeometry.affineLocally (fun {R S} [CommRing R] [CommRing S] => P) f =
∀ (U : ↑Y.affineOpens) (V : ↑X.affineOpens) (e : ↑V ≤ (TopologicalSpace.Opens.map f.base).obj ↑U),
... | false |
Set.singleton_subset_singleton._gcongr_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {a b : α}, a = b → {a} ⊆ {b} | false |
USize.toNat_ofFin | Init.Data.UInt.Lemmas | ∀ (x : Fin USize.size), (USize.ofFin x).toNat = ↑x | true |
_private.Mathlib.GroupTheory.GroupAction.Blocks.0.MulAction.IsBlock.of_subset._simp_1_3 | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : DivisionMonoid G] (a b : G), b⁻¹ * a⁻¹ = (a * b)⁻¹ | false |
Orientation.oangle_sign_sub_smul_left | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x y : V) (r : ℝ), (o.oangle (x - r • y) y).sign = (o.oangle x y).sign | true |
_private.Batteries.Data.Random.MersenneTwister.0.Batteries.Random.MersenneTwister.Config.lMask | Batteries.Data.Random.MersenneTwister | (cfg : Batteries.Random.MersenneTwister.Config) → BitVec cfg.wordSize | true |
Lean.Environment.imports | Lean.Environment | Lean.Environment → Array Lean.Import | true |
Std.Internal.IO.Async.System.GroupInfo.groupName | Std.Internal.Async.System | Std.Internal.IO.Async.System.GroupInfo → String | true |
Std.Internal.List.maxKey!_insertEntryIfNew | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
[inst_4 : Inhabited α] {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ {k : α} {v : β k},
Std.Internal.List.maxKey! (Std.Internal.List.insertEntryIfNew k v l) =
(Std.Internal.List... | true |
_private.Lean.Compiler.LCNF.Simp.SimpValue.0.Lean.Compiler.LCNF.Simp.simpCtorDiscr?.match_6 | Lean.Compiler.LCNF.Simp.SimpValue | (motive : Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure → Sort u_1) →
(e : Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure) →
((declName : Lean.Name) →
(us : List Lean.Level) →
(args : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) →
motive (Le... | false |
_private.Mathlib.Algebra.Ring.GeomSum.0.geom_sum₂_mul_of_le._simp_1_1 | Mathlib.Algebra.Ring.GeomSum | ∀ {n m : ℕ}, (m ∈ Finset.range n) = (m < n) | false |
Mathlib.Tactic.FieldSimp.Sign.mul.match_1 | Mathlib.Tactic.FieldSimp.Lemmas | {v : Lean.Level} →
{M : Q(Type v)} →
(motive : Mathlib.Tactic.FieldSimp.Sign M → Mathlib.Tactic.FieldSimp.Sign M → Sort u_1) →
(g₁ g₂ : Mathlib.Tactic.FieldSimp.Sign M) →
(Unit → motive Mathlib.Tactic.FieldSimp.Sign.plus Mathlib.Tactic.FieldSimp.Sign.plus) →
((i : Q(Field «$M»)) → motive M... | false |
Std.DTreeMap.minKeyD_le_minKeyD_erase | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k : α},
(t.erase k).isEmpty = false → ∀ {fallback : α}, (cmp (t.minKeyD fallback) ((t.erase k).minKeyD fallback)).isLE = true | true |
Std.DHashMap.Internal.Raw.WFImp.mk._flat_ctor | Std.Data.DHashMap.Internal.Defs | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β},
Std.DHashMap.Internal.IsHashSelf m.buckets →
m.size = (Std.DHashMap.Internal.toListModel m.buckets).length →
Std.Internal.List.DistinctKeys (Std.DHashMap.Internal.toListModel m.buckets) → Std.DHashMap.Internal.R... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.