name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Polynomial.quotientSpanCXSubCAlgEquiv._proof_3 | Mathlib.RingTheory.Polynomial.Quotient | ∀ {R : Type u_1} [inst : CommRing R] (x y : R), (Ideal.span {Polynomial.C x, Polynomial.X - Polynomial.C y}).IsTwoSided | false |
AddAction.selfEquivSigmaOrbits | Mathlib.GroupTheory.GroupAction.Defs | (G : Type u_1) →
(α : Type u_2) →
[inst : AddGroup G] →
[inst_1 : AddAction G α] → α ≃ (ω : AddAction.orbitRel.Quotient G α) × ↑(AddAction.orbit G (Quotient.out ω)) | true |
BoolRing.Iso.mk._proof_2 | Mathlib.Algebra.Category.BoolRing | ∀ {α β : BoolRing} (e : ↑α ≃+* ↑β),
CategoryTheory.CategoryStruct.comp { hom' := ↑e.symm } { hom' := ↑e } = CategoryTheory.CategoryStruct.id β | false |
NNRat.coe_zpow._simp_1 | Mathlib.Algebra.Field.Rat | ∀ (p : ℚ≥0) (n : ℤ), ↑p ^ n = ↑(p ^ n) | false |
CategoryTheory.Lax.StrongTrans.app | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} → CategoryTheory.Lax.StrongTrans F G → (a : B) → F.obj a ⟶ G.obj a | true |
PNat.Coprime.gcd_mul_right_cancel_right | Mathlib.Data.PNat.Prime | ∀ (m : ℕ+) {n k : ℕ+}, k.Coprime m → m.gcd (n * k) = m.gcd n | true |
Lean.Server.FileWorker.SignatureHelp.SearchControl.ctorElimType | Lean.Server.FileWorker.SignatureHelp | {motive : Lean.Server.FileWorker.SignatureHelp.SearchControl → Sort u} → ℕ → Sort (max 1 u) | false |
Topology.RelCWComplex.Subcomplex._sizeOf_1 | Mathlib.Topology.CWComplex.Classical.Basic | {X : Type u_1} →
{t : TopologicalSpace X} →
{C D : Set X} →
{inst : Topology.RelCWComplex C D} →
[SizeOf X] → [(a : X) → SizeOf (C a)] → [(a : X) → SizeOf (D a)] → Topology.RelCWComplex.Subcomplex C → ℕ | false |
ENNReal.eq_of_forall_le_nnreal_iff | Mathlib.Data.ENNReal.Inv | ∀ {x y : ENNReal}, (∀ (r : NNReal), x ≤ ↑r ↔ y ≤ ↑r) → x = y | true |
Set.preimage_mul_const_Ici_of_neg | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] (a : α) {c : α},
c < 0 → (fun x => x * c) ⁻¹' Set.Ici a = Set.Iic (a / c) | true |
TrivSqZeroExt.nonAssocSemiring._proof_8 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module Rᵐᵒᵖ M] (x : TrivSqZeroExt R M), 0 * x = 0 | false |
_private.Lean.Meta.Tactic.Grind.ProveEq.0.Lean.Meta.Grind.AbstractM.State._sizeOf_inst | Lean.Meta.Tactic.Grind.ProveEq | SizeOf Lean.Meta.Grind.AbstractM.State✝ | false |
CategoryTheory.MonoidalCategory.MonoidalRightAction.rightActionOfMonoidalOppositeLeftAction | Mathlib.CategoryTheory.Monoidal.Action.Opposites | (C : Type u_1) →
(D : Type u_2) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.Category.{v_2, u_2} D] →
[CategoryTheory.MonoidalCategory.MonoidalLeftAction Cᴹᵒᵖ D] →
CategoryTheory.MonoidalCategory.MonoidalRightAction C D | true |
Mathlib.Tactic.runUse | Mathlib.Tactic.Use | Bool → Lean.Elab.Tactic.TacticM Unit → List Lean.Term → Lean.Elab.Tactic.TacticM Unit | true |
Algebra.IsPushout.cancelBaseChangeAux._proof_6 | Mathlib.RingTheory.IsTensorProduct | ∀ (R : Type u_2) (S : Type u_3) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (A : Type u_1)
[inst_3 : CommRing A] [inst_4 : Algebra R A], SMulCommClass A R (TensorProduct R A S) | false |
Mathlib.Tactic.BicategoryLike.MonadMor₂.mk | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {m : Type → Type} →
(Mathlib.Tactic.BicategoryLike.Mor₂Iso → m Mathlib.Tactic.BicategoryLike.Mor₂) →
(Mathlib.Tactic.BicategoryLike.AtomIso → m Mathlib.Tactic.BicategoryLike.Atom) →
(Mathlib.Tactic.BicategoryLike.Mor₂Iso → m Mathlib.Tactic.BicategoryLike.Mor₂) →
(Mathlib.Tactic.BicategoryLike.AtomIso → m Mathlib.Tactic.BicategoryLike.Atom) →
(Mathlib.Tactic.BicategoryLike.Mor₁ → m Mathlib.Tactic.BicategoryLike.Mor₂) →
(Mathlib.Tactic.BicategoryLike.Mor₂ →
Mathlib.Tactic.BicategoryLike.Mor₂ → m Mathlib.Tactic.BicategoryLike.Mor₂) →
(Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₂ → m Mathlib.Tactic.BicategoryLike.Mor₂) →
(Mathlib.Tactic.BicategoryLike.Mor₂ →
Mathlib.Tactic.BicategoryLike.Mor₁ → m Mathlib.Tactic.BicategoryLike.Mor₂) →
(Mathlib.Tactic.BicategoryLike.Mor₂ →
Mathlib.Tactic.BicategoryLike.Mor₂ → m Mathlib.Tactic.BicategoryLike.Mor₂) →
(Mathlib.Tactic.BicategoryLike.CoherenceHom →
Mathlib.Tactic.BicategoryLike.Mor₂ →
Mathlib.Tactic.BicategoryLike.Mor₂ → m Mathlib.Tactic.BicategoryLike.Mor₂) →
Mathlib.Tactic.BicategoryLike.MonadMor₂ m | true |
Lean.Elab.Tactic.BVDecide.Frontend.CounterExample.mk._flat_ctor | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide | Lean.MVarId →
Std.HashSet Lean.FVarId →
Array (Lean.Expr × Std.Tactic.BVDecide.BVExpr.PackedBitVec) → Lean.Elab.Tactic.BVDecide.Frontend.CounterExample | false |
StateT.run_seqRight | Init.Control.Lawful.Instances | ∀ {m : Type u_1 → Type u_2} {σ α β : Type u_1} [inst : Monad m] (x : StateT σ m α) (y : StateT σ m β) (s : σ),
(x *> y).run s = do
let p ← x.run s
y.run p.2 | true |
UniqueFactorizationMonoid.radical | Mathlib.RingTheory.Radical.Basic | {M : Type u_1} → [inst : CommMonoidWithZero M] → [NormalizationMonoid M] → [UniqueFactorizationMonoid M] → M → M | true |
Mathlib.Tactic.Order.AtomicFact.ne.inj | Mathlib.Tactic.Order.CollectFacts | ∀ {lhs rhs : ℕ} {proof : Lean.Expr} {lhs_1 rhs_1 : ℕ} {proof_1 : Lean.Expr},
Mathlib.Tactic.Order.AtomicFact.ne lhs rhs proof = Mathlib.Tactic.Order.AtomicFact.ne lhs_1 rhs_1 proof_1 →
lhs = lhs_1 ∧ rhs = rhs_1 ∧ proof = proof_1 | true |
Filter.map_map₂_antidistrib_left | Mathlib.Order.Filter.NAry | ∀ {α : Type u_1} {β : Type u_3} {β' : Type u_4} {γ : Type u_5} {δ : Type u_7} {m : α → β → γ} {f : Filter α}
{g : Filter β} {n : γ → δ} {m' : β' → α → δ} {n' : β → β'},
(∀ (a : α) (b : β), n (m a b) = m' (n' b) a) → Filter.map n (Filter.map₂ m f g) = Filter.map₂ m' (Filter.map n' g) f | true |
Filter.lift'_neBot_iff | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {h : Set α → Set β},
Monotone h → ((f.lift' h).NeBot ↔ ∀ s ∈ f, (h s).Nonempty) | true |
Pi.instMul | Mathlib.Algebra.Notation.Pi.Defs | {ι : Type u_1} → {M : ι → Type u_5} → [(i : ι) → Mul (M i)] → Mul ((i : ι) → M i) | true |
List.prefix_rfl | Init.Data.List.Sublist | ∀ {α : Type u_1} {l : List α}, l <+: l | true |
Aesop.Frontend.Priority.noConfusion | Aesop.Frontend.RuleExpr | {P : Sort u} → {t t' : Aesop.Frontend.Priority} → t = t' → Aesop.Frontend.Priority.noConfusionType P t t' | false |
WithIdealFilter.mem_nhds_iff | Mathlib.RingTheory.IdealFilter.Topology | ∀ {A : Type u_1} [inst : Ring A] {F : IdealFilter A} {a : WithIdealFilter F} {s : Set (WithIdealFilter F)},
s ∈ nhds a ↔ ∃ I ∈ F, a +ᵥ WithIdealFilter.idealSet I ⊆ s | true |
isBoundedBilinearMap_smul | Mathlib.Analysis.Normed.Operator.BoundedLinearMaps | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : CommSemiring 𝕜] [inst_1 : SeminormedRing A] [inst_2 : Algebra 𝕜 A]
{E : Type u_3} [inst_3 : SeminormedAddCommGroup E] [inst_4 : Module 𝕜 E] [inst_5 : Module A E] [IsBoundedSMul A E]
[IsScalarTower 𝕜 A E], IsBoundedBilinearMap 𝕜 fun p => p.1 • p.2 | true |
CategoryTheory.Limits.HasFiniteColimits.mk | Mathlib.CategoryTheory.Limits.Shapes.FiniteLimits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C],
(∀ (J : Type) [𝒥 : CategoryTheory.SmallCategory J] [CategoryTheory.FinCategory J],
CategoryTheory.Limits.HasColimitsOfShape J C) →
CategoryTheory.Limits.HasFiniteColimits C | true |
AddSubgroup.mem_even | Mathlib.Algebra.Group.Subgroup.Even | ∀ {G : Type u_1} [inst : AddCommGroup G] {a : G}, a ∈ AddSubgroup.even G ↔ Even a | true |
Order.Ideal.PrimePair.disjoint | Mathlib.Order.PrimeIdeal | ∀ {P : Type u_1} [inst : Preorder P] (IF : Order.Ideal.PrimePair P), Disjoint ↑IF.I ↑IF.F | true |
_private.Mathlib.Data.List.Chain.0.List.isChain_map._proof_1_2 | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {β : Type u_2} {R : α → α → Prop} (f : β → α) (x : β),
List.IsChain R (List.map f [x]) ↔ List.IsChain (fun a b => R (f a) (f b)) [x] | false |
Turing.ToPartrec.instDecidableEqCode.decEq._proof_32 | Mathlib.Computability.TuringMachine.Config | ∀ (a a_1 a_2 a_3 : Turing.ToPartrec.Code), ¬a.comp a_1 = a_2.cons a_3 | false |
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr.reorder | Lean.Meta.Tactic.Grind.Arith.Cutsat.ReorderVars | Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr → Array Int.Linear.Var → Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr | true |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Poly.0.Lean.Grind.CommRing.Poly.toExpr.go._unsafe_rec | Lean.Meta.Tactic.Grind.Arith.CommRing.Poly | Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Expr → Lean.Grind.CommRing.Expr | false |
instPreirreducibleSpaceOfSubsingleton | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} [inst : TopologicalSpace X] [Subsingleton X], PreirreducibleSpace X | true |
Localization.recOnSubsingleton₂ | Mathlib.GroupTheory.MonoidLocalization.Basic | {M : Type u_1} →
[inst : CommMonoid M] →
{S : Submonoid M} →
{r : Localization S → Localization S → Sort u} →
[h : ∀ (a c : M) (b d : ↥S), Subsingleton (r (Localization.mk a b) (Localization.mk c d))] →
(x y : Localization S) → ((a c : M) → (b d : ↥S) → r (Localization.mk a b) (Localization.mk c d)) → r x y | true |
CategoryTheory.Limits.piConst._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Limits.HasProducts C] (X : C)
{X_1 Y Z : Type u_1ᵒᵖ} (f : X_1 ⟶ Y) (g : Y ⟶ Z),
(CategoryTheory.Limits.Pi.map' (CategoryTheory.CategoryStruct.comp f g).unop fun x =>
CategoryTheory.CategoryStruct.id X) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.Pi.map' f.unop fun x => CategoryTheory.CategoryStruct.id X)
(CategoryTheory.Limits.Pi.map' g.unop fun x => CategoryTheory.CategoryStruct.id X) | false |
List.nodup_ofFn_ofInjective | Mathlib.Data.List.FinRange | ∀ {α : Type u} {n : ℕ} {f : Fin n → α}, Function.Injective f → (List.ofFn f).Nodup | true |
HNNExtension.NormalWord.cons.eq_1 | Mathlib.GroupTheory.HNNExtension | ∀ {G : Type u_1} [inst : Group G] {A B : Subgroup G} {d : HNNExtension.NormalWord.TransversalPair G A B} (g : G)
(u : ℤˣ) (w : HNNExtension.NormalWord d) (h1 : w.head ∈ d.set u)
(h2 : ∀ u' ∈ Option.map Prod.fst w.toList.head?, w.head ∈ HNNExtension.toSubgroup A B u → u = u'),
HNNExtension.NormalWord.cons g u w h1 h2 = { head := g, toList := (u, w.head) :: w.toList, chain := ⋯, mem_set := ⋯ } | true |
_private.Mathlib.Algebra.Polynomial.Bivariate.0.Polynomial.Bivariate.pderiv_one_equivMvPolynomial._simp_1_3 | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u} {a : R} [inst : Semiring R] {n : ℕ}, (Polynomial.monomial n) a = Polynomial.C a * Polynomial.X ^ n | false |
CategoryTheory.MonoidalOpposite.tensorIso_hom_app_unmop | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(X : Cᴹᵒᵖ × Cᴹᵒᵖ),
((CategoryTheory.MonoidalOpposite.tensorIso C).hom.app X).unmop =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorObj X.2.unmop X.1.unmop) | true |
Std.Ric.size_eq_match_rcc | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Ric α} [inst : Std.PRange.Least? α] [inst_1 : LE α] [DecidableLE α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.Rxc.HasSize α] [Std.PRange.LawfulUpwardEnumerable α]
[Std.PRange.LawfulUpwardEnumerableLE α] [Std.Rxc.IsAlwaysFinite α] [Std.Rxc.LawfulHasSize α],
r.size =
match Std.PRange.least? with
| none => 0
| some next => (next...=r.upper).size | true |
instToStringOption | Init.Data.ToString.Basic | {α : Type u} → [ToString α] → ToString (Option α) | true |
Set.fintypeTop._proof_1 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u_1}, Function.Injective ⇑(Equiv.Set.univ α).symm | false |
_private.Mathlib.RingTheory.RootsOfUnity.Complex.0.Complex.isPrimitiveRoot_exp_rat_of_even_num.match_1_1 | Mathlib.RingTheory.RootsOfUnity.Complex | ∀ (q : ℚ) (motive : (∃ r, q.num = 2 • r) → Prop) (x : ∃ r, q.num = 2 • r),
(∀ (n : ℤ) (hn : q.num = 2 • n), motive ⋯) → motive x | false |
Matrix.exp_neg | Mathlib.Analysis.Normed.Algebra.MatrixExponential | ∀ {m : Type u_1} {𝔸 : Type u_4} [inst : Fintype m] [inst_1 : DecidableEq m] [inst_2 : NormedCommRing 𝔸]
[NormedAlgebra ℚ 𝔸] [CompleteSpace 𝔸] (A : Matrix m m 𝔸), NormedSpace.exp (-A) = (NormedSpace.exp A)⁻¹ | true |
le_max_of_le_left | Mathlib.Order.MinMax | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, a ≤ b → a ≤ max b c | true |
_private.Mathlib.MeasureTheory.Measure.CharacteristicFunction.TaylorExpansion.0.MeasureTheory.contDiff_charFun'._simp_1_1 | Mathlib.MeasureTheory.Measure.CharacteristicFunction.TaylorExpansion | ∀ {S : Type u_3} {M : outParam (Type u_4)} {inst : One M} {inst_1 : SetLike S M} [self : OneMemClass S M] (s : S),
(1 ∈ s) = True | false |
Std.Tactic.BVDecide.BVExpr.decEq._proof_115 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lw ln : ℕ) (lexpr : Std.Tactic.BVDecide.BVExpr lw) (lh : w = lw * ln) (idx : ℕ),
¬Std.Tactic.BVDecide.BVExpr.replicate ln lexpr lh = Std.Tactic.BVDecide.BVExpr.var idx | false |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.Iter.length_eq_match_step.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β : Type u_1} (motive : Std.IterStep (Std.Iter β) β → Sort u_2) (it' : Std.Iter β) (out : β)
(h_1 : (it' : Std.Iter β) → (out : β) → motive (Std.IterStep.yield it' out))
(h_2 : (it' : Std.Iter β) → motive (Std.IterStep.skip it')) (h_3 : Unit → motive Std.IterStep.done),
(match Std.IterStep.yield it' out with
| Std.IterStep.yield it' out => h_1 it' out
| Std.IterStep.skip it' => h_2 it'
| Std.IterStep.done => h_3 ()) =
h_1 it' out | true |
Lean.ConstructorVal.casesOn | Lean.Declaration | {motive : Lean.ConstructorVal → Sort u} →
(t : Lean.ConstructorVal) →
((toConstantVal : Lean.ConstantVal) →
(induct : Lean.Name) →
(cidx numParams numFields : ℕ) →
(isUnsafe : Bool) →
motive
{ toConstantVal := toConstantVal, induct := induct, cidx := cidx, numParams := numParams,
numFields := numFields, isUnsafe := isUnsafe }) →
motive t | false |
Mathlib.Tactic.withResetServerInfo.Result.rec | Mathlib.Tactic.Basic | {α : Type} →
{motive : Mathlib.Tactic.withResetServerInfo.Result α → Sort u} →
((result? : Option α) →
(msgs : Lean.MessageLog) →
(trees : Lean.PersistentArray Lean.Elab.InfoTree) →
motive { result? := result?, msgs := msgs, trees := trees }) →
(t : Mathlib.Tactic.withResetServerInfo.Result α) → motive t | false |
UInt32.instIsAlwaysFinite | Init.Data.Range.Polymorphic.UInt | Std.Rxc.IsAlwaysFinite UInt32 | true |
_private.Mathlib.Analysis.Calculus.FDeriv.Add.0.hasFDerivWithinAt_comp_add_left._simp_1_1 | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {α : Type u_2} {β : Type u_3} [inst : VAdd α β] {t : Set β} {a : α}, a +ᵥ t = (fun x => a +ᵥ x) '' t | false |
Lean.SubExpr.ctorIdx | Lean.SubExpr | Lean.SubExpr → ℕ | false |
LinearEquiv.toModuleIsoₛ | Mathlib.Algebra.Category.ModuleCat.Semi | {R : Type u} →
[inst : Semiring R] →
{X₁ X₂ : Type v} →
{g₁ : AddCommMonoid X₁} →
{g₂ : AddCommMonoid X₂} →
{m₁ : Module R X₁} → {m₂ : Module R X₂} → (X₁ ≃ₗ[R] X₂) → (SemimoduleCat.of R X₁ ≅ SemimoduleCat.of R X₂) | true |
Lean.Widget.HighlightedMsgEmbed.expr.elim | Lean.Server.FileWorker.WidgetRequests | {motive_1 : Lean.Widget.HighlightedMsgEmbed → Sort u} →
(t : Lean.Widget.HighlightedMsgEmbed) →
t.ctorIdx = 0 →
((a : Lean.Widget.HighlightedCodeWithInfos) → motive_1 (Lean.Widget.HighlightedMsgEmbed.expr a)) → motive_1 t | false |
CategoryTheory.Limits.createsColimitsOfShapeOfCreatesCoequalizersAndCoproducts | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : CategoryTheory.SmallCategory J] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete J) D] →
[CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete ((p : J × J) × (p.1 ⟶ p.2))) D] →
[CategoryTheory.Limits.HasCoequalizers D] →
(G : CategoryTheory.Functor C D) →
[G.ReflectsIsomorphisms] →
[CategoryTheory.CreatesColimitsOfShape CategoryTheory.Limits.WalkingParallelPair G] →
[CategoryTheory.CreatesColimitsOfShape (CategoryTheory.Discrete J) G] →
[CategoryTheory.CreatesColimitsOfShape (CategoryTheory.Discrete ((p : J × J) × (p.1 ⟶ p.2)))
G] →
CategoryTheory.CreatesColimitsOfShape J G | true |
Lean.Meta.Grind.Arith.Cutsat.getDivThm? | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToInt | Lean.Meta.Grind.Arith.Cutsat.ToIntM (Option Lean.Expr) | true |
InnerProductSpace.Core.mk._flat_ctor | Mathlib.Analysis.InnerProductSpace.Defs | {𝕜 : Type u_4} →
{F : Type u_5} →
[inst : RCLike 𝕜] →
[inst_1 : AddCommGroup F] →
[inst_2 : Module 𝕜 F] →
(inner : F → F → 𝕜) →
(∀ (x y : F), (starRingEnd 𝕜) (inner y x) = inner x y) →
(∀ (x : F), 0 ≤ RCLike.re (inner x x)) →
(∀ (x y z : F), inner (x + y) z = inner x z + inner y z) →
(∀ (x y : F) (r : 𝕜), inner (r • x) y = (starRingEnd 𝕜) r * inner x y) →
(∀ (x : F), inner x x = 0 → x = 0) → InnerProductSpace.Core 𝕜 F | false |
_private.Mathlib.Data.List.Basic.0.List.mem_dropLast_of_mem_of_ne_getLastD._proof_1_2 | Mathlib.Data.List.Basic | ∀ {α : Type u_1} {l : List α}, l.length - 1 + 1 ≤ l.length → l.length - 1 < l.length | false |
Bornology.vonNBornology._proof_2 | Mathlib.Analysis.LocallyConvex.Bounded | ∀ (𝕜 : Type u_2) (E : Type u_1) [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E], ∀ x ∈ setOf (Bornology.IsVonNBounded 𝕜), ∀ x_1 ⊆ x, Bornology.IsVonNBounded 𝕜 x_1 | false |
mdifferentiableAt_mul_left | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {G : Type u_4}
[inst_4 : Mul G] [inst_5 : TopologicalSpace G] [inst_6 : ChartedSpace H G] [ContMDiffMul I 1 G] {a b : G},
(MDiffAt fun x => a * x) b | true |
String.Internal.dropImpl | Init.Data.String.TakeDrop | String → ℕ → String | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastRotateRight.go_get._proof_1_3 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight | ∀ {w : ℕ} (distance curr idx : ℕ), curr = idx → ¬idx = curr → False | false |
_private.Mathlib.NumberTheory.LucasLehmer.0.legendreSym_mersenne_two._proof_1_1 | Mathlib.NumberTheory.LucasLehmer | ∀ {p : ℕ}, mersenne p % 8 = 7 → ¬mersenne p = 2 | false |
SeparationQuotient.instNonUnitalNormedCommRing._proof_4 | Mathlib.Analysis.Normed.Ring.Lemmas | ∀ {α : Type u_1} [inst : NonUnitalSeminormedCommRing α] (a b : SeparationQuotient α), a * b = b * a | false |
Finset.Iic_pred_eq_Iio | Mathlib.Order.Interval.Finset.SuccPred | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : LocallyFiniteOrderBot α] [inst_2 : PredOrder α] [NoMinOrder α]
(b : α), Finset.Iic (Order.pred b) = Finset.Iio b | true |
SetRel.preimage_eq_image | Mathlib.Data.Rel | ∀ {α : Type u_1} {s : Set α} {R : SetRel α α} [R.IsSymm], R.preimage s = R.image s | true |
Int.bmod_add_bmod | Init.Data.Int.DivMod.Lemmas | ∀ {x : ℤ} {n : ℕ} {y : ℤ}, (x.bmod n + y).bmod n = (x + y).bmod n | true |
HahnSeries.orderTop_eq_top | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] {x : HahnSeries Γ R}, x.orderTop = ⊤ ↔ x = 0 | true |
AddSubmonoid.LocalizationMap.addEquivOfLocalizations_right_inv | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N] {P : Type u_3}
[inst_2 : AddCommMonoid P] (f : S.LocalizationMap N) (k : S.LocalizationMap P),
f.ofAddEquivOfLocalizations (f.addEquivOfLocalizations k) = k | true |
instMeasureSpaceUnitAddCircle | Mathlib.Analysis.Fourier.AddCircleMulti | MeasureTheory.MeasureSpace UnitAddCircle | true |
Aesop.RuleFilter.matchesLocalNormSimpRule? | Aesop.RuleSet.Filter | Aesop.RuleFilter → Option Lean.Name | true |
Std.Roc.Sliceable.casesOn | Init.Data.Slice.Notation | {α : Type u} →
{β : Type v} →
{γ : Type w} →
{motive : Std.Roc.Sliceable α β γ → Sort u_1} →
(t : Std.Roc.Sliceable α β γ) → ((mkSlice : α → Std.Roc β → γ) → motive { mkSlice := mkSlice }) → motive t | false |
_private.Mathlib.Order.CompactlyGenerated.Basic.0.Directed.disjoint_iSup_right._simp_1_1 | Mathlib.Order.CompactlyGenerated.Basic | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b = ⊥) | false |
MeasureTheory.Measure.instIsProbabilityMeasureBindCoeKernelOfIsMarkovKernel | Mathlib.Probability.Kernel.Composition.MeasureComp | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {μ : MeasureTheory.Measure α}
{κ : ProbabilityTheory.Kernel α β} [MeasureTheory.IsProbabilityMeasure μ] [ProbabilityTheory.IsMarkovKernel κ],
MeasureTheory.IsProbabilityMeasure (μ.bind ⇑κ) | true |
Real.tendsto_exp_neg_atTop_nhds_zero | Mathlib.Analysis.SpecialFunctions.Exp | Filter.Tendsto (fun x => Real.exp (-x)) Filter.atTop (nhds 0) | true |
Std.ExtDHashMap.Const.size_filter_eq_size_iff | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {f : α → β → Bool},
(Std.ExtDHashMap.filter f m).size = m.size ↔
∀ (a : α) (h : a ∈ m), f (m.getKey a h) (Std.ExtDHashMap.Const.get m a h) = true | true |
CategoryTheory.Abelian.Ext.comp_hom | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y Z : C} [inst_3 : HasDerivedCategory C] {a b : ℕ}
(α : CategoryTheory.Abelian.Ext X Y a) (β : CategoryTheory.Abelian.Ext Y Z b) {c : ℕ} (h : a + b = c),
(α.comp β h).hom = α.hom.comp β.hom ⋯ | true |
_private.Batteries.Data.RBMap.Alter.0.Batteries.RBMap.alter.adapt.match_1.eq_1 | Batteries.Data.RBMap.Alter | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (h_1 : Unit → motive none) (h_2 : (v : β) → motive (some v)),
(match none with
| none => h_1 ()
| some v => h_2 v) =
h_1 () | true |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.bv_elim_signExtend._regBuiltin.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.bv_elim_signExtend.declare_1._@.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc.996641769._hygCtx._hyg.16 | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc | IO Unit | false |
Filter.HasBasis.uniformEquicontinuousOn_iff | Mathlib.Topology.UniformSpace.Equicontinuity | ∀ {ι : Type u_1} {α : Type u_6} {β : Type u_8} [uα : UniformSpace α] [uβ : UniformSpace β] {κ₁ : Type u_11}
{κ₂ : Type u_12} {p₁ : κ₁ → Prop} {s₁ : κ₁ → Set (β × β)} {p₂ : κ₂ → Prop} {s₂ : κ₂ → Set (α × α)} {F : ι → β → α}
{S : Set β},
(uniformity β ⊓ Filter.principal (S ×ˢ S)).HasBasis p₁ s₁ →
(uniformity α).HasBasis p₂ s₂ →
(UniformEquicontinuousOn F S ↔
∀ (k₂ : κ₂), p₂ k₂ → ∃ k₁, p₁ k₁ ∧ ∀ (x y : β), (x, y) ∈ s₁ k₁ → ∀ (i : ι), (F i x, F i y) ∈ s₂ k₂) | true |
eVariationOn.comp_eq_of_monotoneOn | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] {E : Type u_2} [inst_1 : PseudoEMetricSpace E] {β : Type u_3}
[inst_2 : LinearOrder β] (f : α → E) {t : Set β} (φ : β → α),
MonotoneOn φ t → eVariationOn (f ∘ φ) t = eVariationOn f (φ '' t) | true |
Option.map_inj_right | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {o o' : Option α},
(∀ (x y : α), f x = f y → x = y) → (Option.map f o = Option.map f o' ↔ o = o') | true |
Lean.Meta.Grind.UnitLike.State.mk.noConfusion | Lean.Meta.Tactic.Grind.Types | {P : Sort u} →
{map map' : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option Lean.Expr)} →
{ map := map } = { map := map' } → (map = map' → P) → P | false |
HeytAlg.carrier | Mathlib.Order.Category.HeytAlg | HeytAlg → Type u_1 | true |
Traversable.foldMap | Mathlib.Control.Fold | {t : Type u → Type u} → [Traversable t] → {α ω : Type u} → [One ω] → [Mul ω] → (α → ω) → t α → ω | true |
Lean.OptionDecl.ctorIdx | Lean.Data.Options | Lean.OptionDecl → ℕ | false |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.StainData.mk.sizeOf_spec | Mathlib.Tactic.Linter.FlexibleLinter | ∀ (stained : Mathlib.Linter.Flexible.Stained✝) (stx : Lean.Syntax) (ci : Lean.Elab.ContextInfo)
(mctx : Lean.MetavarContext) (goals : List Lean.MVarId),
sizeOf { stained := stained, stx := stx, ci := ci, mctx := mctx, goals := goals } =
1 + sizeOf stained + sizeOf stx + sizeOf ci + sizeOf mctx + sizeOf goals | true |
UInt64.toFin_shiftRight | Init.Data.UInt.Bitwise | ∀ (a b : UInt64), b < 64 → (a >>> b).toFin = a.toFin >>> b.toFin | true |
Submonoid.pi_empty | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {ι : Type u_4} {M : ι → Type u_5} [inst : (i : ι) → MulOneClass (M i)] (H : (i : ι) → Submonoid (M i)),
Submonoid.pi ∅ H = ⊤ | true |
Unitization.algHom_ext' | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A]
[inst_3 : SMulCommClass R A A] [inst_4 : IsScalarTower R A A] {C : Type u_5} [inst_5 : Semiring C]
[inst_6 : Algebra R C] {φ ψ : Unitization R A →ₐ[R] C},
(↑φ).comp (Unitization.inrNonUnitalAlgHom R A) = (↑ψ).comp (Unitization.inrNonUnitalAlgHom R A) → φ = ψ | true |
Lean.Elab.Tactic.SimpKind.rec | Lean.Elab.Tactic.Simp | {motive : Lean.Elab.Tactic.SimpKind → Sort u} →
motive Lean.Elab.Tactic.SimpKind.simp →
motive Lean.Elab.Tactic.SimpKind.simpAll →
motive Lean.Elab.Tactic.SimpKind.dsimp → (t : Lean.Elab.Tactic.SimpKind) → motive t | false |
CategoryTheory.MorphismProperty.arrow_mk_iso_iff | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.MorphismProperty C) [P.RespectsIso]
{W X Y Z : C} {f : W ⟶ X} {g : Y ⟶ Z} (e : CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk g), P f ↔ P g | true |
SetLike.gmodule._proof_1 | Mathlib.Algebra.Module.GradedModule | ∀ {ιA : Type u_3} {ιM : Type u_4} {A : Type u_5} {M : Type u_1} {σ : Type u_2} {σ' : Type u_6} [inst : AddMonoid ιA]
[inst_1 : AddAction ιA ιM] [inst_2 : Semiring A] (𝓐 : ιA → σ') [inst_3 : SetLike σ' A] (𝓜 : ιM → σ)
[inst_4 : AddCommMonoid M] [inst_5 : Module A M] [inst_6 : SetLike σ M] [SetLike.GradedSMul 𝓐 𝓜] {i : ιA} {j : ιM}
(x : ↥(𝓐 i)) (y : ↥(𝓜 j)), ↑x • ↑y ∈ 𝓜 (i +ᵥ j) | false |
Std.DTreeMap.Raw.get_get? | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] (h : t.WF) {a : α} {h' : (t.get? a).isSome = true}, (t.get? a).get h' = t.get a ⋯ | true |
Finset.univ_div_univ | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : DivisionMonoid α] [inst_2 : Fintype α],
Finset.univ / Finset.univ = Finset.univ | true |
IsStarProjection.zero._simp_1 | Mathlib.Algebra.Star.StarProjection | ∀ (R : Type u_1) [inst : NonUnitalNonAssocSemiring R] [inst_1 : StarAddMonoid R], IsStarProjection 0 = True | false |
Lean.Expr.NumObjs.State.mk.noConfusion | Lean.Util.NumObjs | {P : Sort u} →
{visited : Lean.PtrSet Lean.Expr} →
{counter : ℕ} →
{visited' : Lean.PtrSet Lean.Expr} →
{counter' : ℕ} →
{ visited := visited, counter := counter } = { visited := visited', counter := counter' } →
(visited = visited' → counter = counter' → P) → P | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.