name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_diff_of_contains_eq_false_right._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
SetLike.GradeZero.instAlgebraSubtypeMemOfNat | Mathlib.Algebra.DirectSum.Internal | {ι : Type u_1} →
{σ : Type u_2} →
{R : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : AddMonoid ι] →
[inst_2 : SetLike σ R] →
[inst_3 : AddSubmonoidClass σ R] → (A : ι → σ) → [inst_4 : SetLike.GradedMonoid A] → Algebra (↥(A 0)) R | true |
Plausible.List.shrinkable | Plausible.Sampleable | {α : Type u_1} → [Plausible.Shrinkable α] → Plausible.Shrinkable (List α) | true |
Nat.instIdempotentOpHOr | Init.Data.Nat.Bitwise.Lemmas | Std.IdempotentOp fun x1 x2 => x1 ||| x2 | true |
Lean.Elab.InfoState.casesOn | Lean.Elab.InfoTree.Types | {motive : Lean.Elab.InfoState → Sort u} →
(t : Lean.Elab.InfoState) →
((enabled : Bool) →
(assignment : Lean.PersistentHashMap Lean.MVarId Lean.Elab.InfoTree) →
(lazyAssignment : Lean.PersistentHashMap Lean.MVarId (Task Lean.Elab.InfoTree)) →
(trees : Lean.PersistentArray Lean.Elab.I... | false |
Std.CancellationContext.State.ctorIdx | Std.Sync.CancellationContext | Std.CancellationContext.State → ℕ | false |
LinearMap.module._proof_1 | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R : Type u_1} {R₂ : Type u_2} {S : Type u_5} {M : Type u_3} {M₂ : Type u_4} [inst : Semiring R]
[inst_1 : Semiring R₂] [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M]
[inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂} [inst_6 : Semiring S] [inst_7 : Module S M₂] [inst_8 : SMulCommClass R₂ S M₂... | false |
cfc_map_prod | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Pi | ∀ {A : Type u_1} {B : Type u_2} {R : Type u_3} {S : Type u_4} [inst : CommSemiring R] [inst_1 : StarRing R]
[inst_2 : MetricSpace R] [inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : CommRing S]
[inst_6 : Algebra R S] [inst_7 : Ring A] [inst_8 : Ring B] [inst_9 : Algebra S A] [inst_10 : Algeb... | true |
Order.IsSuccLimit.add_one_lt | Mathlib.Algebra.Order.SuccPred | ∀ {α : Type u_1} {x y : α} [inst : PartialOrder α] [inst_1 : Add α] [inst_2 : One α] [SuccAddOrder α],
Order.IsSuccLimit x → y < x → y + 1 < x | true |
AlgebraicIndependent.iff_adjoin_image | Mathlib.RingTheory.AlgebraicIndependent.Transcendental | ∀ {ι : Type u_1} {R : Type u_3} {A : Type v} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A]
[inst_2 : Algebra R A] (s : Set ι),
AlgebraicIndependent R x ↔
(AlgebraicIndependent R fun i => x ↑i) ∧ AlgebraicIndepOn (↥(Algebra.adjoin R (x '' s))) x sᶜ | true |
FixedBy.subfield._proof_4 | Mathlib.FieldTheory.Fixed | ∀ {M : Type u_2} [inst : Monoid M] (F : Type u_1) [inst_1 : Field F] [inst_2 : MulSemiringAction M F] (m : M), m • 0 = 0 | false |
ValuativeRel.«_aux_Mathlib_RingTheory_Valuation_ValuativeRel_Basic___macroRules_ValuativeRel_term_=ᵥ__2» | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | Lean.Macro | false |
Circle.norm_coe | Mathlib.Analysis.Complex.Circle | ∀ (z : Circle), ‖↑z‖ = 1 | true |
LinearIsometry.toLinearMap | Mathlib.Analysis.Normed.Operator.LinearIsometry | {R : Type u_1} →
{R₂ : Type u_2} →
[inst : Semiring R] →
[inst_1 : Semiring R₂] →
{σ₁₂ : R →+* R₂} →
{E : Type u_11} →
{E₂ : Type u_12} →
[inst_2 : SeminormedAddCommGroup E] →
[inst_3 : SeminormedAddCommGroup E₂] →
[inst_4 : Modul... | true |
IsHausdorff.haus | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal R} {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M],
IsHausdorff I M → ∀ (x : M), (∀ (n : ℕ), x ≡ 0 [SMOD I ^ n • ⊤]) → x = 0 | true |
Lean.IR.UnboxResult.unboxAttr | Lean.Compiler.IR.UnboxResult | Lean.TagAttribute | true |
CategoryTheory.GrothendieckTopology.Point.skyscraperPresheafHomEquiv_naturality_right_assoc | Mathlib.CategoryTheory.Sites.Point.Skyscraper | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} (Φ : J.Point)
{A : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} A] [inst_2 : CategoryTheory.Limits.HasProducts A]
{P : CategoryTheory.Functor Cᵒᵖ A} {M N : A} [inst_3 : CategoryTheory.Limits.HasColimitsOfSize... | true |
TopModuleCat.instIsLeftAdjointModuleCatWithModuleTopology | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | ∀ (R : Type u) [inst : Ring R] [inst_1 : TopologicalSpace R], (TopModuleCat.withModuleTopology R).IsLeftAdjoint | true |
AddSubmonoid.add_def | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_4} [inst : AddZeroClass M] (S : AddSubmonoid M) (x y : ↥S), x + y = ⟨↑x + ↑y, ⋯⟩ | true |
_private.Mathlib.Data.Set.Lattice.0.Set.insert_iUnion._simp_1_1 | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {s : Set α} {a : α}, insert a s = s ∪ {a} | false |
Lean.Meta.Grind.Arith.Cutsat.instInhabitedFindIntValResult | Lean.Meta.Tactic.Grind.Arith.Cutsat.Search | Inhabited Lean.Meta.Grind.Arith.Cutsat.FindIntValResult | true |
_private.Init.Data.List.Basic.0.List.lengthTRAux.match_1.eq_1 | Init.Data.List.Basic | ∀ {α : Type u_1} (motive : List α → ℕ → Sort u_2) (n : ℕ) (h_1 : (n : ℕ) → motive [] n)
(h_2 : (head : α) → (as : List α) → (n : ℕ) → motive (head :: as) n),
(match [], n with
| [], n => h_1 n
| head :: as, n => h_2 head as n) =
h_1 n | true |
modularCyclotomicCharacter.toFun_spec | Mathlib.NumberTheory.Cyclotomic.CyclotomicCharacter | ∀ {L : Type u} [inst : CommRing L] [inst_1 : IsDomain L] (g : L ≃+* L) {n : ℕ} [inst_2 : NeZero n]
(t : ↥(rootsOfUnity n L)), g ↑↑t = ↑(↑t ^ (modularCyclotomicCharacter.toFun n g).val) | true |
_private.Mathlib.Data.Nat.Prime.Defs.0.Nat.prime_iff_not_exists_mul_eq._simp_1_3 | Mathlib.Data.Nat.Prime.Defs | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, ((∃ x, p x) → b) = ∀ (x : α), p x → b | false |
Ideal.Quotient.groupWithZero._proof_11 | Mathlib.RingTheory.Ideal.Quotient.Basic | ∀ {R : Type u_1} [inst : Ring R] (I : Ideal R) [inst_1 : I.IsTwoSided] [hI : I.IsMaximal], 0⁻¹ = 0 | false |
CategoryTheory.Localization.Preadditive.add_eq_add | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Preadditive | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Preadditive C]
{L : CategoryTheory.Functor C D} (W : CategoryTheory.MorphismProperty C) [inst_3 : L.IsLocalization W]
[inst_4 : W.HasLeftCalculusOfFractions] {X Y ... | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.MBTC.0.Lean.Meta.Grind.Arith.Linear.getAssignmentExt?.match_1 | Lean.Meta.Tactic.Grind.Arith.Linear.MBTC | (motive : Option ℚ → Sort u_1) → (x : Option ℚ) → ((v : ℚ) → motive (some v)) → ((x : Option ℚ) → motive x) → motive x | false |
Con.coe_inf | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Mul M] {c d : Con M}, ⇑(c ⊓ d) = ⇑c ⊓ ⇑d | true |
MvPolynomial.sumAlgEquiv_apply | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u) (S₁ : Type v) (S₂ : Type w) [inst : CommSemiring R] (a : MvPolynomial (S₁ ⊕ S₂) R),
(MvPolynomial.sumAlgEquiv R S₁ S₂) a = (MvPolynomial.sumToIter R S₁ S₂) a | true |
AlgebraicGeometry.Scheme.Pullback.Triplet.hx | Mathlib.AlgebraicGeometry.PullbackCarrier | ∀ {X Y S : AlgebraicGeometry.Scheme} {f : X ⟶ S} {g : Y ⟶ S} (self : AlgebraicGeometry.Scheme.Pullback.Triplet f g),
f self.x = self.s | true |
MonoidAlgebra.addHom_ext' | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] {N : Type u_8} [inst_1 : AddZeroClass N]
⦃f g : MonoidAlgebra R M →+ N⦄,
(∀ (m : M), f.comp (MonoidAlgebra.singleAddHom m) = g.comp (MonoidAlgebra.singleAddHom m)) → f = g | true |
CategoryTheory.Adjunction.mapMon_counit | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (a : F ⊣ G) [inst_4 : F.Monoidal]
[ins... | true |
Cardinal.add_eq_self | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {c : Cardinal.{u_1}}, Cardinal.aleph0 ≤ c → c + c = c | true |
Lean.Elab.Term.withoutHeedElabAsElimImp | Lean.Elab.Term.TermElabM | {α : Type} → Lean.Elab.TermElabM α → Lean.Elab.TermElabM α | true |
List.scanlM_pure | Init.Data.List.Scan.Lemmas | ∀ {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} {init : β} [inst : Monad m] [LawfulMonad m] {f : β → α → β}
{as : List α}, List.scanlM (fun x1 x2 => pure (f x1 x2)) init as = pure (List.scanl f init as) | true |
_private.Lean.Compiler.IR.Basic.0.Lean.IR.Expr.alphaEqv._sparseCasesOn_6 | Lean.Compiler.IR.Basic | {motive : Lean.IR.Expr → Sort u} →
(t : Lean.IR.Expr) →
((n offset : ℕ) → (x : Lean.IR.VarId) → motive (Lean.IR.Expr.sproj n offset x)) →
(Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.instMonoidalFunctorInverseCongrLeft._proof_15 | Mathlib.CategoryTheory.Monoidal.FunctorCategory | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_6, u_5} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] (E : Type u_4) [inst_2 : CategoryTheory.Category.{u_2, u_4} E]
[inst_3 : CategoryTheory.MonoidalCategory E] (e : C ≌ D),
autoParam
(∀ {X Y : CategoryTheory.Functor D E} (X' : CategoryT... | false |
CategoryTheory.Monad.mu_naturality | Mathlib.CategoryTheory.Monad.Basic | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (T : CategoryTheory.Monad C) ⦃X Y : C⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (T.map (T.map f)) (T.μ.app Y) =
CategoryTheory.CategoryStruct.comp (T.μ.app X) (T.map f) | true |
Submodule.mapQ | Mathlib.LinearAlgebra.Quotient.Basic | {R : Type u_1} →
{M : Type u_2} →
[inst : Ring R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
(p : Submodule R M) →
{R₂ : Type u_3} →
{M₂ : Type u_4} →
[inst_3 : Ring R₂] →
[inst_4 : AddCommGroup M₂] →
... | true |
Lean.Parser.Command.mutual._regBuiltin.Lean.Parser.Command.mutual_1 | Lean.Parser.Command | IO Unit | false |
Measurable.eventuallyMeasurable_of_eventuallyEq | Mathlib.MeasureTheory.MeasurableSpace.EventuallyMeasurable | ∀ {α : Type u_1} {m : MeasurableSpace α} {l : Filter α} [inst : CountableInterFilter l] {β : Type u_2}
[inst_1 : MeasurableSpace β] {f g : α → β}, Measurable f → g =ᶠ[l] f → EventuallyMeasurable m l g | true |
CategoryTheory.StructuredArrow.homMk._auto_1 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | Lean.Syntax | false |
PrimeSpectrum.isIdempotentElemEquivClopens_symm_compl | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u} [inst : CommRing R] (s : TopologicalSpace.Clopens (PrimeSpectrum R)),
PrimeSpectrum.isIdempotentElemEquivClopens.symm sᶜ = ⟨1 - ↑(PrimeSpectrum.isIdempotentElemEquivClopens.symm s), ⋯⟩ | true |
HomogeneousLocalization.NumDenSameDeg.instCommMonoid | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | {ι : Type u_1} →
{A : Type u_2} →
{σ : Type u_3} →
[inst : CommRing A] →
[inst_1 : SetLike σ A] →
[inst_2 : AddSubmonoidClass σ A] →
{𝒜 : ι → σ} →
(x : Submonoid A) →
[inst_3 : AddCommMonoid ι] →
[inst_4 : DecidableEq ι] → [Grade... | true |
TrivSqZeroExt.hasSum_inl | Mathlib.Topology.Instances.TrivSqZeroExt | ∀ {α : Type u_1} {R : Type u_3} (M : Type u_4) [inst : TopologicalSpace R] [inst_1 : TopologicalSpace M]
[inst_2 : AddCommMonoid R] [inst_3 : AddCommMonoid M] {f : α → R} {a : R},
HasSum f a → HasSum (fun x => TrivSqZeroExt.inl (f x)) (TrivSqZeroExt.inl a) | true |
Monoid.PushoutI.NormalWord.equivPair.eq_1 | Mathlib.GroupTheory.PushoutI | ∀ {ι : Type u_1} {G : ι → Type u_2} {H : Type u_3} [inst : (i : ι) → Group (G i)] [inst_1 : Group H]
{φ : (i : ι) → H →* G i} {d : Monoid.PushoutI.NormalWord.Transversal φ} [inst_2 : DecidableEq ι]
[inst_3 : (i : ι) → DecidableEq (G i)] (i : ι),
Monoid.PushoutI.NormalWord.equivPair i =
{
toFun := fun w ... | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.eraseList_perm_filter_not_contains._simp_1_4 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} (a : α) {l₁ l₂ : List α}, (a :: l₁).Perm (a :: l₂) = l₁.Perm l₂ | false |
FreeGroupBasis.instFunLike._proof_1 | Mathlib.GroupTheory.FreeGroup.IsFreeGroup | ∀ {ι : Type u_1} {G : Type u_2} [inst : Group G], Function.Injective fun b i => b.repr.symm (FreeGroup.of i) | false |
Lean.instReprModuleHeader.repr | Lean.Setup | Lean.ModuleHeader → ℕ → Std.Format | true |
List.decidableLex._proof_2 | Init.Data.List.Basic | ∀ {α : Type u_1} (r : α → α → Prop) (head : α) (tail : List α), List.Lex r (head :: tail) [] → False | false |
_private.Lean.DocString.Formatter.0.Lean.Doc.Parser.versoSyntaxToString' | Lean.DocString.Formatter | Lean.Syntax → ReaderT ℕ (StateM String) Unit | true |
Traversable.naturality_pf | Mathlib.Control.Traversable.Lemmas | ∀ {t : Type u → Type u} [inst : Traversable t] [LawfulTraversable t] {F G : Type u → Type u} [inst_2 : Applicative F]
[LawfulApplicative F] [inst_4 : Applicative G] [LawfulApplicative G] {α β : Type u}
(η : ApplicativeTransformation F G) (f : α → F β),
traverse ((fun {α} => η.app α) ∘ f) = (fun {α} => η.app α) ∘ ... | true |
MeasureTheory.SimpleFunc.FinMeasSupp.map₂ | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {m : MeasurableSpace α} [inst : Zero β] [inst_1 : Zero γ]
{μ : MeasureTheory.Measure α} {f : MeasureTheory.SimpleFunc α β} [inst_2 : Zero δ],
f.FinMeasSupp μ →
∀ {g : MeasureTheory.SimpleFunc α γ},
g.FinMeasSupp μ →
∀ {op : β → γ → δ}, ... | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract.go.congr_simp | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {newWidth : ℕ} {aig : Std.Sat.AIG α} {w : ℕ}
(input input_1 : aig.RefVec w),
input = input_1 →
∀ (start start_1 : ℕ),
start = start_1 →
∀ (curr : ℕ) (hcurr : curr ≤ newWidth) (s s_1 : aig.RefVec curr),
s = s_1 →
Std.Ta... | true |
Localization.mulEquivOfQuotient_symm_mk' | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N]
{f : S.LocalizationMap N} (x : M) (y : ↥S),
(Localization.mulEquivOfQuotient f).symm (f.mk' x y) = (Localization.monoidOf S).mk' x y | true |
_private.Mathlib.Geometry.Group.Growth.QuotientInter.0.Finset.card_pow_quotient_mul_pow_inter_subgroup_le._simp_1_9 | Mathlib.Geometry.Group.Growth.QuotientInter | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {b : β},
(b ∈ Finset.image f s) = ∃ a ∈ s, f a = b | false |
_private.Mathlib.MeasureTheory.Integral.Bochner.Set.0.MeasureTheory.setIntegral_mono_on._simp_1_1 | Mathlib.MeasureTheory.Integral.Bochner.Set | ∀ {α : Type u} {f : Filter α} {p : α → Prop} {s : Set α},
(∀ᶠ (x : α) in f ⊓ Filter.principal s, p x) = ∀ᶠ (x : α) in f, x ∈ s → p x | false |
Equiv.propEquivBool | Mathlib.Logic.Equiv.Defs | Prop ≃ Bool | true |
MeasureTheory.limsup_measure_le_of_le_liminf_measure_compl | Mathlib.MeasureTheory.Measure.Portmanteau | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] {ι : Type u_2} {L : Filter ι} {μ : MeasureTheory.Measure Ω}
{μs : ι → MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure μ]
[∀ (i : ι), MeasureTheory.IsProbabilityMeasure (μs i)] {E : Set Ω},
MeasurableSet E → μ Eᶜ ≤ Filter.liminf (fun i => (μs i) Eᶜ) L → Filt... | true |
neg_neg_of_pos | Mathlib.Algebra.Order.Group.Defs | ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α] {a : α}, 0 < a → -a < 0 | true |
DirectSum.lmap_id | Mathlib.Algebra.DirectSum.Module | ∀ {R : Type u} [inst : Semiring R] {ι : Type v} {M : ι → Type w} [inst_1 : (i : ι) → AddCommMonoid (M i)]
[inst_2 : (i : ι) → Module R (M i)], (DirectSum.lmap fun i => LinearMap.id) = LinearMap.id | true |
_private.Lean.Compiler.LCNF.ExplicitBoxing.0.Lean.Compiler.LCNF.castArgsIfNeeded.match_1 | Lean.Compiler.LCNF.ExplicitBoxing | (motive :
Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.impure) ×
Array (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.impure) →
Sort u_1) →
(__discr :
Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.impure) ×
Array (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.L... | false |
Lean.Widget.RpcEncodablePacket.expr.inj._@.Lean.Server.FileWorker.WidgetRequests.2377472685._hygCtx._hyg.1 | Lean.Server.FileWorker.WidgetRequests | ∀ {a a_1 : Lean.Json}, Lean.Widget.RpcEncodablePacket.expr✝ a = Lean.Widget.RpcEncodablePacket.expr✝ a_1 → a = a_1 | false |
Cubic.ne_zero_of_b_ne_zero | Mathlib.Algebra.CubicDiscriminant | ∀ {R : Type u_1} {P : Cubic R} [inst : Semiring R], P.b ≠ 0 → P.toPoly ≠ 0 | true |
Matrix.kroneckerTMul_assoc | Mathlib.LinearAlgebra.Matrix.Kronecker | ∀ (R : Type u_1) {α : Type u_3} {β : Type u_5} {γ : Type u_7} {l : Type u_9} {m : Type u_10} {n : Type u_11}
{p : Type u_12} {q : Type u_13} {r : Type u_14} [inst : CommSemiring R] [inst_1 : AddCommMonoid α]
[inst_2 : AddCommMonoid β] [inst_3 : AddCommMonoid γ] [inst_4 : Module R α] [inst_5 : Module R β]
[inst_6 ... | true |
Mathlib.Tactic.MkIff.Shape.ctorIdx | Mathlib.Tactic.MkIffOfInductiveProp | Mathlib.Tactic.MkIff.Shape → ℕ | false |
CategoryTheory.Grp.limitAux._proof_11 | Mathlib.CategoryTheory.Monoidal.Cartesian.GrpLimits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{J : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} J] [inst_3 : CategoryTheory.Limits.HasLimitsOfShape J C]
(F : CategoryTheory.Functor J (CategoryTheory.Grp C)) (X : C)
(f : X ⟶ (Category... | false |
CategoryTheory.Pretriangulated.Triangle.mor₂ | Mathlib.CategoryTheory.Triangulated.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.HasShift C ℤ] → (self : CategoryTheory.Pretriangulated.Triangle C) → self.obj₂ ⟶ self.obj₃ | true |
FaithfulSMul.eq_of_smul_eq_smul | Mathlib.Algebra.Group.Action.Faithful | ∀ {M : Type u_4} {α : Type u_5} {inst : SMul M α} [self : FaithfulSMul M α] {m₁ m₂ : M},
(∀ (a : α), m₁ • a = m₂ • a) → m₁ = m₂ | true |
Asymptotics.isLittleO_pow_sub_pow_sub | Mathlib.Analysis.Asymptotics.Lemmas | ∀ {E' : Type u_6} [inst : SeminormedAddCommGroup E'] (x₀ : E') {n m : ℕ},
n < m → (fun x => ‖x - x₀‖ ^ m) =o[nhds x₀] fun x => ‖x - x₀‖ ^ n | true |
CategoryTheory.Arrow.mapCechConerve | Mathlib.AlgebraicTopology.CechNerve | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{f g : CategoryTheory.Arrow C} →
[inst_1 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePushout f.left (fun x => f.right) fun x => f.hom] →
[inst_2 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePushout g.left (fun x => g.right) fun x => g.hom] →
... | true |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.neg_eq_not_add | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc | Lean.Meta.Simp.Simproc | true |
Bundle.TotalSpace.exists._simp_1 | Mathlib.Data.Bundle | ∀ {B : Type u_1} {F : Type u_2} {E : B → Type u_3} {p : Bundle.TotalSpace F E → Prop}, (∃ x, p x) = ∃ b y, p ⟨b, y⟩ | false |
CategoryTheory.Limits.HasFiniteProducts.casesOn | Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.Limits.HasFiniteProducts C → Sort u_1} →
(t : CategoryTheory.Limits.HasFiniteProducts C) →
((out : ∀ (n : ℕ), CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete (Fin n)) C) → motive ⋯) →
motive... | false |
Finset.mem_one | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : One α] {a : α}, a ∈ 1 ↔ a = 1 | true |
_private.Mathlib.Order.Filter.Pi.0.Filter.coprodᵢ_neBot_iff._simp_1_1 | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)},
(Filter.coprodᵢ f).NeBot = ((∀ (i : ι), Nonempty (α i)) ∧ ∃ d, (f d).NeBot) | false |
SaturatedSubmonoid.instSubmonoidClass | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ (M : Type u_1) [inst : MulOneClass M], SubmonoidClass (SaturatedSubmonoid M) M | true |
SMulPosReflectLE.recOn | Mathlib.Algebra.Order.Module.Defs | {α : Type u_1} →
{β : Type u_2} →
[inst : SMul α β] →
[inst_1 : Preorder α] →
[inst_2 : Preorder β] →
[inst_3 : Zero β] →
{motive : SMulPosReflectLE α β → Sort u} →
(t : SMulPosReflectLE α β) →
((le_of_smul_le_smul_right : ∀ ⦃b : β⦄, 0 < b → ∀ ⦃a₁ ... | false |
Finsupp.subtypeDomain_finsupp_sum | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} {N : Type u_6} [inst : AddCommMonoid M] {p : α → Prop} [inst_1 : Zero N]
{s : β →₀ N} {h : β → N → α →₀ M},
Finsupp.subtypeDomain p (s.sum h) = s.sum fun c d => Finsupp.subtypeDomain p (h c d) | true |
isRightRegular_ofColex | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : Monoid α] {a : Colex α}, IsRightRegular (ofColex a) ↔ IsRightRegular a | true |
CondensedMod.LocallyConstant.fullyFaithfulFunctor._proof_1 | Mathlib.Condensed.Discrete.Module | ∀ (R : Type (u_1 + 1)) [inst : Ring R] {X Y : ModuleCat R} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CondensedMod.LocallyConstant.functor R).comp (Condensed.underlying (ModuleCat R))).map f)
((fun M => (CondensedMod.LocallyConstant.functorIsoDiscreteAux₁ R M).symm) Y).hom =
CategoryTheory.Cat... | false |
Std.ExtHashSet.ctorIdx | Std.Data.ExtHashSet.Basic | {α : Type u} → {inst : BEq α} → {inst_1 : Hashable α} → Std.ExtHashSet α → ℕ | false |
CategoryTheory.Abelian.AbelianStruct._sizeOf_inst | Mathlib.CategoryTheory.Abelian.Basic | {C : Type u_1} →
{inst : CategoryTheory.Category.{u_2, u_1} C} →
{inst_1 : CategoryTheory.Preadditive C} →
{X Y : C} → (f : X ⟶ Y) → [SizeOf C] → SizeOf (CategoryTheory.Abelian.AbelianStruct f) | false |
BitVec.neg_eq_intMin | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, -x = BitVec.intMin w ↔ x = BitVec.intMin w | true |
ULift.monoid._proof_3 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u_2} [inst : Monoid α] (x : ULift.{u_1, u_2} α) (x_1 : ℕ), Equiv.ulift (x ^ x_1) = Equiv.ulift (x ^ x_1) | false |
Subring.integralClosure_le_iff | Mathlib.RingTheory.IntegralClosure.IntegrallyClosed | ∀ {R : Type u_1} [inst : CommRing R] {A : Type u_2} [inst_1 : CommRing A] [inst_2 : Algebra R A] {T : Subring A}
[IsIntegrallyClosedIn (↥T) A], (integralClosure R A).toSubring ≤ T ↔ ∀ (r : R), (algebraMap R A) r ∈ T | true |
Dyadic.noConfusion | Init.Data.Dyadic.Basic | {P : Sort u} → {t t' : Dyadic} → t = t' → Dyadic.noConfusionType P t t' | false |
LinearIsometryEquiv.image_closedBall | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
[inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E] [inst_7 : Mo... | true |
Filter.instMul.eq_1 | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Mul α],
Filter.instMul =
{
mul := fun f g =>
let __src := Filter.map₂ (fun x1 x2 => x1 * x2) f g;
{ sets := {s | ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ * t₂ ⊆ s}, univ_sets := ⋯, sets_of_superset := ⋯, inter_sets := ⋯ } } | true |
Lean.Lsp.CompletionIdentifier.fvar.inj | Lean.Data.Lsp.LanguageFeatures | ∀ {id id_1 : Lean.FVarId}, Lean.Lsp.CompletionIdentifier.fvar id = Lean.Lsp.CompletionIdentifier.fvar id_1 → id = id_1 | true |
Mathlib.Tactic.Ring.ExProd.mul | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{sα : Q(CommSemiring «$α»)} →
{x : Q(«$α»)} →
{e : Q(ℕ)} →
{b : Q(«$α»)} →
Mathlib.Tactic.Ring.ExBase sα x →
Mathlib.Tactic.Ring.ExProd Mathlib.Tactic.Ring.sℕ e →
Mathlib.Tactic.Ring.ExProd sα b → Mathlib.Tactic... | true |
Filter.Tendsto.const_sub | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : Sub G] [ContinuousSub G] (b : G) {c : G} {f : α → G}
{l : Filter α}, Filter.Tendsto f l (nhds c) → Filter.Tendsto (fun x => b - f x) l (nhds (b - c)) | true |
_private.Mathlib.Data.Nat.Choose.Basic.0.Nat.choose_le_middle_of_le_half_left | Mathlib.Data.Nat.Choose.Basic | ∀ {n r : ℕ}, r ≤ n / 2 → n.choose r ≤ n.choose (n / 2) | true |
norm_lt_of_mem_ball | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedAddGroup E] {a b : E} {r : ℝ}, b ∈ Metric.ball a r → ‖b‖ < ‖a‖ + r | true |
_private.Mathlib.Topology.Algebra.Module.FiniteDimension.0.FiniteDimensional.of_totallyBounded_nhds_zero._proof_1_3 | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {E : Type u_1} [inst : AddCommGroup E] ⦃x : E⦄ (m u : ℕ → E),
(∀ (n : ℕ), (fun x1 x2 => x1 + x2) (m n) (u n) = x) → m = fun n => x - u n | false |
CategoryTheory.Triangulated.TStructure.isGE_truncGT_obj | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryT... | true |
Lean.BaseMessage.mk.noConfusion | Lean.Message | {α : Type u} →
{P : Sort u_1} →
{fileName : String} →
{pos : Lean.Position} →
{endPos : Option Lean.Position} →
{keepFullRange : Bool} →
{severity : Lean.MessageSeverity} →
{isSilent : Bool} →
{caption : String} →
{data : α} →
... | false |
Lean.Meta.Tactic.TryThis.SuggestionText.prettyExtra | Lean.Meta.TryThis | Lean.Meta.Tactic.TryThis.SuggestionText → optParam (Option ℕ) none → optParam ℕ 0 → optParam ℕ 0 → Lean.CoreM String | true |
ENNReal.instCompleteLinearOrder | Mathlib.Data.ENNReal.Basic | CompleteLinearOrder ENNReal | true |
Nat.ofNat_le | Mathlib.Data.Nat.Cast.Order.Basic | ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α] [AddLeftMono α] [ZeroLEOneClass α] [CharZero α]
{m n : ℕ} [inst_5 : n.AtLeastTwo] [inst_6 : m.AtLeastTwo],
OfNat.ofNat m ≤ OfNat.ofNat n ↔ OfNat.ofNat m ≤ OfNat.ofNat n | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.