name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
BitVec.ushiftRight_eq'._simp_1 | Std.Tactic.BVDecide.Normalize.Canonicalize | ∀ {w₁ w₂ : ℕ} (x : BitVec w₁) (y : BitVec w₂), x >>> y.toNat = x >>> y | false |
Language.toDFA | Mathlib.Computability.MyhillNerode | {α : Type u} → (L : Language α) → DFA α ↑(Set.range L.leftQuotient) | true |
Monoid.mk._flat_ctor | Mathlib.Algebra.Group.Defs | {M : Type u} →
(mul : M → M → M) →
(∀ (a b c : M), a * b * c = a * (b * c)) →
(one : M) →
(∀ (a : M), 1 * a = a) →
(∀ (a : M), a * 1 = a) →
(npow : ℕ → M → M) →
autoParam (∀ (x : M), npow 0 x = 1) Monoid.npow_zero._autoParam →
autoParam (∀ (n : ℕ) ... | false |
Lean.Parser.instInhabitedParserInfo.default | Lean.Parser.Types | Lean.Parser.ParserInfo | true |
Std.List.stream_drop_eq_drop | Batteries.Data.Stream | ∀ {α : Type u_1} {n : ℕ} (l : List α), Std.Stream.drop l n = List.drop n l | true |
Polynomial.eq_X_add_C_of_natDegree_le_one | Mathlib.Algebra.Polynomial.Degree.SmallDegree | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R},
p.natDegree ≤ 1 → p = Polynomial.C (p.coeff 1) * Polynomial.X + Polynomial.C (p.coeff 0) | true |
Array.takeWhile_map | Init.Data.Array.Extract | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {p : β → Bool} {as : Array α},
Array.takeWhile p (Array.map f as) = Array.map f (Array.takeWhile (p ∘ f) as) | true |
Std.ExtDTreeMap.self_le_maxKey!_insert | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k : α} {v : β k}, (cmp k (t.insert k v).maxKey!).isLE = true | true |
GromovHausdorff.instInhabitedGHSpace | Mathlib.Topology.MetricSpace.GromovHausdorff | Inhabited GromovHausdorff.GHSpace | true |
List.eraseIdx_eq_self | Init.Data.List.Erase | ∀ {α : Type u_1} {l : List α} {k : ℕ}, l.eraseIdx k = l ↔ l.length ≤ k | true |
neg_add_cancel_left | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} [inst : AddGroup G] (a b : G), -a + (a + b) = b | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Horn.0.SSet.horn_obj_zero._simp_1_12 | Mathlib.AlgebraicTopology.SimplicialSet.Horn | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | false |
CategoryTheory.over._auto_1 | Mathlib.CategoryTheory.Comma.Over.OverClass | Lean.Syntax | false |
IsClosedMap.codRestrict | Mathlib.Topology.Constructions | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsClosedMap f → ∀ {s : Set Y} (hs : ∀ (a : X), f a ∈ s), IsClosedMap (Set.codRestrict f s hs) | true |
Option.any_none | Init.Data.Option.Basic | ∀ {α : Type u_1} {p : α → Bool}, Option.any p none = false | true |
Lean.Elab.enableInfoTree | Lean.Elab.InfoTree.Main | {m : Type → Type} → [Lean.Elab.MonadInfoTree m] → optParam Bool true → m Unit | true |
_private.Mathlib.Combinatorics.SimpleGraph.Walks.Subwalks.0.SimpleGraph.Walk.isSubwalk_iff_darts_isInfix._proof_1_46 | Mathlib.Combinatorics.SimpleGraph.Walks.Subwalks | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} {p₁ : G.Walk u v} (i : ℕ),
i - 1 + 1 ≤ p₁.support.tail.length → i - 1 < p₁.support.tail.length | false |
_private.Mathlib.Algebra.Order.Field.Basic.0.Mathlib.Meta.Positivity.evalInv.match_3 | Mathlib.Algebra.Order.Field.Basic | {u : Lean.Level} →
{α : Q(Type u)} →
(zα : Q(Zero «$α»)) →
(pα : Q(PartialOrder «$α»)) →
(a : Q(«$α»)) →
(motive : Mathlib.Meta.Positivity.Strictness zα pα a → Sort u_1) →
(ra : Mathlib.Meta.Positivity.Strictness zα pα a) →
((pa : Q(0 < «$a»)) → motive (Mathlib.Me... | false |
_private.Mathlib.CategoryTheory.FiberedCategory.BasedCategory.0.CategoryTheory.BasedNatTrans.instReflectsIsomorphismsBasedFunctorFunctorObjForgetful._simp_1 | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₂} 𝒳] [inst_1 : CategoryTheory.Category.{v₂, u₁} 𝒮]
(p : CategoryTheory.Functor 𝒳 𝒮) (S : 𝒮) {a b : 𝒳} (φ : a ⟶ b) [inst_2 : CategoryTheory.IsIso φ]
[p.IsHomLift (CategoryTheory.CategoryStruct.id S) φ],
p.IsHomLift (CategoryTheory.Categor... | false |
_private.Mathlib.Algebra.Lie.Weights.IsSimple.0.LieAlgebra.IsKilling.chi_not_in_q_aux.match_1_3 | Mathlib.Algebra.Lie.Weights.IsSimple | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : LieRing L] [inst_2 : LieAlgebra K L]
[inst_3 : FiniteDimensional K L] {H : LieSubalgebra K L} [inst_4 : H.IsCartanSubalgebra]
(S : RootPairing (↥LieSubalgebra.root) K (Module.Dual K ↥H) ↥H) (i j : ↥LieSubalgebra.root)
(motive : S.root i - S.root j ∈ Set.r... | false |
AdjoinRoot.mapAlgEquiv._proof_6 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_3} {S : Type u_2} {T : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] [inst_4 : Algebra R T] (f : S ≃ₐ[R] T) (p : Polynomial S) (q : Polynomial T),
Associated (Polynomial.map (↑f) p) q → q ∣ Polynomial.map (↑f) p | false |
Associates.isUnit_iff_eq_one | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoid M] (a : Associates M), IsUnit a ↔ a = 1 | true |
mul_lt_mul_of_neg_left | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : PartialOrder R] {a b c : R} [ExistsAddOfLE R] [PosMulStrictMono R]
[AddRightStrictMono R] [AddRightReflectLT R], b < a → c < 0 → c * a < c * b | true |
MonCat.Colimits.descFunLift.eq_3 | Mathlib.Algebra.Category.MonCat.Colimits | ∀ {J : Type v} [inst : CategoryTheory.Category.{u, v} J] (F : CategoryTheory.Functor J MonCat)
(s : CategoryTheory.Limits.Cocone F) (x_1 y : MonCat.Colimits.Prequotient F),
MonCat.Colimits.descFunLift F s (x_1.mul y) = MonCat.Colimits.descFunLift F s x_1 * MonCat.Colimits.descFunLift F s y | true |
_private.Mathlib.Algebra.Group.Finsupp.0.Finsupp.addCommute_of_disjoint._simp_1_2 | Mathlib.Algebra.Group.Finsupp | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, Disjoint s t = (s ∩ t = ∅) | false |
_private.Mathlib.Algebra.Category.CommAlgCat.Basic.0.CommAlgCat.mk._flat_ctor | Mathlib.Algebra.Category.CommAlgCat.Basic | {R : Type u} →
[inst : CommRing R] →
(carrier : Type v) → [commRing : CommRing carrier] → [algebra : Algebra R carrier] → CommAlgCat R | false |
CategoryTheory.Sieve.essSurjFullFunctorGaloisInsertion | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) →
[F.EssSurj] →
[F.Full] →
(X : C) →
GaloisInsertion (CategoryTheory.Sieve.functorPushfor... | true |
extChartAt_target_eventuallyEq_of_mem | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
{I : ModelWithCorners 𝕜 E H} [inst_5 : ChartedSpace H M] {x : M} {z : E},
z ∈ (extChartAt I x)... | true |
_private.Mathlib.Algebra.Polynomial.RuleOfSigns.0.List.filter.match_1.eq_1 | Mathlib.Algebra.Polynomial.RuleOfSigns | ∀ (motive : Bool → Sort u_1) (h_1 : Unit → motive true) (h_2 : Unit → motive false),
(match true with
| true => h_1 ()
| false => h_2 ()) =
h_1 () | true |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.AssocList.foldrM.eq_2 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type w'} [inst : Monad m] (f : (a : α) → β a → δ → m δ)
(x : δ) (a : α) (b : β a) (es : Std.DHashMap.Internal.AssocList α β),
Std.DHashMap.Internal.AssocList.foldrM f x (Std.DHashMap.Internal.AssocList.cons a b es) = do
let d ← Std.DHashMap.Internal.Ass... | true |
Mathlib.Notation3.mkFoldlMatcher | Mathlib.Util.Notation3 | Lean.Name →
Lean.Name →
Lean.Name →
Lean.Term →
Lean.Term → Array Lean.Name → OptionT Lean.Elab.TermElabM (List Mathlib.Notation3.DelabKey × Lean.Term) | true |
_private.Lean.Compiler.CSimpAttr.0.Lean.Compiler.CSimp.isConstantReplacement?._sparseCasesOn_1 | Lean.Compiler.CSimpAttr | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
algebraMap_comp_natCast | Mathlib.Algebra.Algebra.Basic | ∀ (R : Type u_2) (A : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
⇑(algebraMap R A) ∘ Nat.cast = Nat.cast | true |
ArchimedeanClass.stdPart_eq_sSup | Mathlib.Algebra.Order.Ring.StandardPart | ∀ {K : Type u_1} [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K] (f : ℝ →+*o K) (x : K),
ArchimedeanClass.stdPart x = sSup {r | f r < x} | true |
Fintype.prod_empty | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {M : Type u_3} [inst : Fintype ι] [inst_1 : CommMonoid M] [IsEmpty ι] (f : ι → M), ∏ x, f x = 1 | true |
instAddCommMonoidFormalMultilinearSeries._proof_6 | Mathlib.Analysis.Calculus.FormalMultilinearSeries | ∀ (𝕜 : Type u_1) (E : Type u_2) (F : Type u_3) [inst : Semiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] [inst_5 : ContinuousConstSMul 𝕜 E] [inst_6 : AddCommMonoid F]
[inst_7 : Module 𝕜 F] [inst_8 : TopologicalSpace F] [inst_9 : ContinuousAdd ... | false |
CategoryTheory.Limits.WidePushout.head | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | {J : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{B : C} →
{objs : J → C} →
(arrows : (j : J) → B ⟶ objs j) →
[inst_1 : CategoryTheory.Limits.HasWidePushout B objs arrows] →
B ⟶ CategoryTheory.Limits.widePushout B objs arrows | true |
BooleanSubalgebra.mem_comap | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} {β : Type u_3} [inst : BooleanAlgebra α] [inst_1 : BooleanAlgebra β] {f : BoundedLatticeHom α β}
{a : α} {L : BooleanSubalgebra β}, a ∈ BooleanSubalgebra.comap f L ↔ f a ∈ L | true |
Std.TreeSet.get!_insertMany_list_of_mem | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {l : List α}
{k : α}, k ∈ t → (t.insertMany l).get! k = t.get! k | true |
Int.gcd_sub_right_right_of_dvd | Init.Data.Int.Gcd | ∀ {n k : ℤ} (m : ℤ), n ∣ k → n.gcd (m - k) = n.gcd m | true |
Representation.coinvariantsToFinsupp._proof_1 | Mathlib.RepresentationTheory.Coinvariants | ∀ {k : Type u_3} {G : Type u_4} {V : Type u_1} [inst : CommRing k] [inst_1 : Group G] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] (ρ : Representation k G V) (α : Type u_2) (x : G),
Finsupp.mapRange.linearMap (Representation.Coinvariants.mk ρ) ∘ₗ (ρ.finsupp α) x =
Finsupp.mapRange.linearMap (Representation.C... | false |
Lean.Meta.coeDeclAttr._regBuiltin.Lean.Meta.coeDeclAttr.declRange_3 | Lean.Meta.Coe | IO Unit | false |
_private.Mathlib.MeasureTheory.Function.ConditionalLExpectation.0.MeasureTheory.measurable_condLExp'._simp_1_1 | Mathlib.MeasureTheory.Function.ConditionalLExpectation | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] [inst_2 : Zero α],
Measurable 0 = True | false |
_private.Mathlib.Topology.Sets.CompactOpenCovered.0.IsCompactOpenCovered.exists_mem_of_isBasis._simp_1_8 | Mathlib.Topology.Sets.CompactOpenCovered | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | false |
Subalgebra.algebraicClosure | Mathlib.RingTheory.Algebraic.Integral | (R : Type u_1) →
(S : Type u_2) → [inst : CommRing R] → [inst_1 : CommRing S] → [inst_2 : Algebra R S] → [IsDomain R] → Subalgebra R S | true |
Submodule.orthogonal_disjoint | Mathlib.Analysis.InnerProductSpace.Orthogonal | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E), Disjoint K Kᗮ | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer.0.CategoryTheory.Limits.WalkingMultispan.functorExt.match_1.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {J : CategoryTheory.Limits.MultispanShape} (motive : CategoryTheory.Limits.WalkingMultispan J → Sort u_3) (i : J.L)
(h_1 : (i : J.L) → motive (CategoryTheory.Limits.WalkingMultispan.left i))
(h_2 : (i : J.R) → motive (CategoryTheory.Limits.WalkingMultispan.right i)),
(match CategoryTheory.Limits.WalkingMultispa... | true |
CategoryTheory.ComposableArrows.homMk₅_app_three | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {f g : CategoryTheory.ComposableArrows C 5}
(app₀ : f.obj' 0 _proof_441✝ ⟶ g.obj' 0 _proof_441✝¹) (app₁ : f.obj' 1 _proof_442✝ ⟶ g.obj' 1 _proof_442✝¹)
(app₂ : f.obj' 2 _proof_443✝ ⟶ g.obj' 2 _proof_443✝¹) (app₃ : f.obj' 3 _proof_444✝ ⟶ g.obj' 3 _proof_... | true |
BitVec.reverse.eq_1 | Init.Data.BitVec.Lemmas | ∀ (x_2 : BitVec 0), x_2.reverse = x_2 | true |
WithTop.coe_sInf._simp_1 | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrderBot α] {s : Set α},
s.Nonempty → BddBelow s → ⨅ a ∈ s, ↑a = ↑(sInf s) | false |
SemistandardYoungTableau.casesOn | Mathlib.Combinatorics.Young.SemistandardTableau | {μ : YoungDiagram} →
{motive : SemistandardYoungTableau μ → Sort u} →
(t : SemistandardYoungTableau μ) →
((entry : ℕ → ℕ → ℕ) →
(row_weak' : ∀ {i j1 j2 : ℕ}, j1 < j2 → (i, j2) ∈ μ → entry i j1 ≤ entry i j2) →
(col_strict' : ∀ {i1 i2 j : ℕ}, i1 < i2 → (i2, j) ∈ μ → entry i1 j < entry i2... | false |
Lean.Compiler.LCNF.SpecEntry.mk.sizeOf_spec | Lean.Compiler.LCNF.SpecInfo | ∀ (declName : Lean.Name) (paramsInfo : Array Lean.Compiler.LCNF.SpecParamInfo) (alreadySpecialized : Bool),
sizeOf { declName := declName, paramsInfo := paramsInfo, alreadySpecialized := alreadySpecialized } =
1 + sizeOf declName + sizeOf paramsInfo + sizeOf alreadySpecialized | true |
Real.sinh_eq_tsum | Mathlib.Analysis.SpecialFunctions.Trigonometric.Series | ∀ (r : ℝ), Real.sinh r = ∑' (n : ℕ), r ^ (2 * n + 1) / ↑(2 * n + 1).factorial | true |
CategoryTheory.InducedWideCategory.Hom.mk.congr_simp | Mathlib.CategoryTheory.Widesubcategory | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₂} D] {F : C → D}
{P : CategoryTheory.MorphismProperty D} [inst_1 : P.IsMultiplicative] {X Y : CategoryTheory.InducedWideCategory D F P}
(hom hom_1 : F X ⟶ F Y) (e_hom : hom = hom_1) (property : P hom),
{ hom := hom, property := property } = { ho... | true |
CategoryTheory.MonoidalCategory.«term𝟙__» | Mathlib.CategoryTheory.Monoidal.Category | Lean.ParserDescr | true |
Turing.ListBlank.tail_cons | Mathlib.Computability.TuringMachine.Tape | ∀ {Γ : Type u_1} [inst : Inhabited Γ] (a : Γ) (l : Turing.ListBlank Γ), (Turing.ListBlank.cons a l).tail = l | true |
ContinuousLinearMap.completion._proof_4 | Mathlib.Topology.Algebra.LinearMapCompletion | ∀ {α : Type u_1} {β : Type u_2} {R₁ : Type u_3} {R₂ : Type u_4} [inst : UniformSpace α] [inst_1 : AddCommGroup α]
[inst_2 : Semiring R₁] [inst_3 : Module R₁ α] [inst_4 : Semiring R₂] [inst_5 : UniformSpace β]
[inst_6 : AddCommGroup β] [inst_7 : Module R₂ β] {σ : R₁ →+* R₂} (f : α →SL[σ] β),
Continuous (UniformSpa... | false |
LinearGrowth.le_linearGrowthSup_iff | Mathlib.Analysis.Asymptotics.LinearGrowth | ∀ {u : ℕ → EReal} {a : EReal}, a ≤ LinearGrowth.linearGrowthSup u ↔ ∀ b < a, ∃ᶠ (n : ℕ) in Filter.atTop, b * ↑n ≤ u n | true |
Lean.Meta.Tactic.Backtrack.BacktrackConfig.discharge._default | Lean.Meta.Tactic.Backtrack | Lean.MVarId → Lean.MetaM (Option (List Lean.MVarId)) | false |
_private.Std.Data.ExtTreeMap.Lemmas.0.Std.ExtTreeMap.alter_eq_empty_iff._simp_1_1 | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t t' : Std.ExtTreeMap α β cmp}, (t = t') = (t.inner = t'.inner) | false |
_private.Mathlib.Control.Basic.0.map_seq._simp_1_1 | Mathlib.Control.Basic | ∀ {f : Type u → Type v} {inst : Applicative f} [self : LawfulApplicative f] {α β : Type u} (g : α → β) (x : f α),
g <$> x = pure g <*> x | false |
Numbering.prefixedEquiv._proof_14 | Mathlib.Combinatorics.KatonaCircle | ∀ {X : Type u_1} [inst : Fintype X] [inst_1 : DecidableEq X] (s : Finset X), ∀ x ∉ s, x ∈ sᶜ | false |
Order.IsSuccLimit.sSup_Iio | Mathlib.Order.SuccPred.CompleteLinearOrder | ∀ {α : Type u_2} [inst : ConditionallyCompleteLinearOrderBot α] {x : α}, Order.IsSuccLimit x → sSup (Set.Iio x) = x | true |
Std.Tactic.BVDecide.LRAT.Internal.Clause.isUnit | Std.Tactic.BVDecide.LRAT.Internal.Clause | {α : outParam (Type u)} →
{β : Type v} → [self : Std.Tactic.BVDecide.LRAT.Internal.Clause α β] → β → Option (Std.Sat.Literal α) | true |
IsLocalizedModule.commonDenom | Mathlib.Algebra.Module.LocalizedModule.Int | {R : Type u_1} →
[inst : CommSemiring R] →
(S : Submonoid R) →
{M : Type u_2} →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
{M' : Type u_3} →
[inst_3 : AddCommMonoid M'] →
[inst_4 : Module R M'] →
(f : M →ₗ[R] M') → [IsLo... | true |
TensorPower.gMul._proof_4 | Mathlib.LinearAlgebra.TensorPower.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {i j : ℕ},
IsScalarTower R R (PiTensorProduct R fun i => M) | false |
AntivaryOn.empty | Mathlib.Order.Monotone.Monovary | ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : ι → α} {g : ι → β},
AntivaryOn f g ∅ | true |
CategoryTheory.Limits.initialMonoClass_of_coproductsDisjoint | Mathlib.CategoryTheory.Limits.Shapes.DisjointCoproduct | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.BinaryCoproductsDisjoint C],
CategoryTheory.Limits.InitialMonoClass C | true |
DifferentiableOn.sub_iff_left._simp_2 | 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}
{s : Set E}, DifferentiableOn 𝕜 g s → DifferentiableOn 𝕜 (f - g) s = DifferentiableOn 𝕜 f s | false |
BitVec.noConfusionType | Init.Prelude | Sort u → {w : ℕ} → BitVec w → {w' : ℕ} → BitVec w' → Sort u | false |
SimpleGraph.IsCompleteBetween.disjoint | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} (G : SimpleGraph V) {s t : Set V}, G.IsCompleteBetween s t → Disjoint s t | true |
BialgCat.category | Mathlib.Algebra.Category.BialgCat.Basic | {R : Type u} → [inst : CommRing R] → CategoryTheory.Category.{v, max (v + 1) u} (BialgCat R) | true |
_private.Mathlib.Algebra.Ring.NonZeroDivisors.0.le_nonZeroDivisorsLeft_iff_isLeftRegular._simp_1_1 | Mathlib.Algebra.Ring.NonZeroDivisors | ∀ {A : Type u_1} {B : Type u_2} [inst : SetLike A B] [inst_1 : LE A] [IsConcreteLE A B] {S T : A},
(S ≤ T) = ∀ ⦃x : B⦄, x ∈ S → x ∈ T | false |
Fin.castLT_sub_nezero._proof_2 | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} {i j : Fin n}, i < j → n - ↑i ≠ 0 | false |
norm_pow | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedRing α] [NormOneClass α] [NormMulClass α] (a : α) (n : ℕ), ‖a ^ n‖ = ‖a‖ ^ n | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.minKey?_eq_some_iff_getKey?_eq_self_and_forall._simp_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {b : α} {α_1 : Type u_2} {x : Option α_1} {f : α_1 → α},
(Option.map f x = some b) = ∃ a, x = some a ∧ f a = b | false |
Lean.instHashableLevelMVarId.hash | Lean.Level | Lean.LevelMVarId → UInt64 | true |
AlgHomClass.toRingHomClass | Mathlib.Algebra.Algebra.Hom | ∀ {F : Type u_1} {R : outParam (Type u_2)} {A : outParam (Type u_3)} {B : outParam (Type u_4)} {inst : CommSemiring R}
{inst_1 : Semiring A} {inst_2 : Semiring B} {inst_3 : Algebra R A} {inst_4 : Algebra R B} {inst_5 : FunLike F A B}
[self : AlgHomClass F R A B], RingHomClass F A B | true |
suggestSteps | Mathlib.Tactic.Widget.Calc | Array Lean.SubExpr.GoalsLocation →
Lean.Expr → CalcParams → Lean.MetaM (String × String × Option (String.Pos.Raw × String.Pos.Raw)) | true |
AffineSubspace.direction_bot | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ (k : Type u_1) (V : Type u_2) (P : Type u_3) [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P], ⊥.direction = ⊥ | true |
DerivedCategory.instPretriangulated._proof_1 | Mathlib.Algebra.Homology.DerivedCategory.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C],
(HomotopyCategory.subcategoryAcyclic C).trW.IsCompatibleWithTriangulation | false |
connectedComponentIn_mem_nhds | Mathlib.Topology.Connected.LocallyConnected | ∀ {α : Type u} [inst : TopologicalSpace α] [LocallyConnectedSpace α] {F : Set α} {x : α},
F ∈ nhds x → connectedComponentIn F x ∈ nhds x | true |
_private.Lean.Elab.DeclModifiers.0.Lean.Elab.Modifiers.isPartial._sparseCasesOn_1 | Lean.Elab.DeclModifiers | {motive : Lean.Elab.RecKind → Sort u} →
(t : Lean.Elab.RecKind) → motive Lean.Elab.RecKind.partial → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
TensorialAt.mkHom₂ | Mathlib.Geometry.Manifold.VectorBundle.Tensoriality | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{H : Type u_3} →
[inst_3 : TopologicalSpace H] →
{I : ModelWithCorners 𝕜 E H} →
{M : Type u_4} →
... | true |
zpow_one_add | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] (a : G) (n : ℤ), a ^ (1 + n) = a * a ^ n | true |
Subbimodule.mk._proof_5 | Mathlib.Algebra.Module.Bimodule | ∀ {R : Type u_4} {A : Type u_2} {B : Type u_3} {M : Type u_1} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : Semiring A] [inst_4 : Semiring B] [inst_5 : Module A M] [inst_6 : Module B M]
[inst_7 : Algebra R A] [inst_8 : Algebra R B] [inst_9 : IsScalarTower R A M] [inst_10 : IsSca... | false |
Absorbs.zero | Mathlib.Topology.Bornology.Absorbs | ∀ {M : Type u_1} {E : Type u_2} [inst : Bornology M] [inst_1 : Zero E] [inst_2 : SMulZeroClass M E] {s : Set E},
0 ∈ s → Absorbs M s 0 | true |
InformationTheory.klDiv_of_not_ac | Mathlib.InformationTheory.KullbackLeibler.Basic | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ ν : MeasureTheory.Measure α},
¬μ.AbsolutelyContinuous ν → InformationTheory.klDiv μ ν = ⊤ | true |
MeasureTheory.Measure.haarMeasure_eq_iff | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalGroup G]
[inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] [SecondCountableTopology G]
(K₀ : TopologicalSpace.PositiveCompacts G) (μ : MeasureTheory.Measure G) [MeasureTheory.SigmaFinite μ]
[μ.IsMulLeftInvariant], MeasureThe... | true |
FreeMonoid.lift_restrict | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {M : Type u_4} [inst : Monoid M] (f : FreeMonoid α →* M), FreeMonoid.lift (⇑f ∘ FreeMonoid.of) = f | true |
Filter.tendsto_atTop_atBot_of_antitone | Mathlib.Order.Filter.AtTopBot.Tendsto | ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
Antitone f → (∀ (b : β), ∃ a, f a ≤ b) → Filter.Tendsto f Filter.atTop Filter.atBot | true |
String.append_left_inj | Init.Data.String.Defs | ∀ {s₁ s₂ : String} (t : String), s₁ ++ t = s₂ ++ t ↔ s₁ = s₂ | true |
TwoUniqueSums.of_addOpposite | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {G : Type u} [inst : Add G], TwoUniqueSums Gᵃᵒᵖ → TwoUniqueSums G | true |
CategoryTheory.Cat.HasLimits.limitConeX_str | Mathlib.CategoryTheory.Category.Cat.Limit | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CategoryTheory.Cat),
(CategoryTheory.Cat.HasLimits.limitConeX F).str = inferInstance | true |
Lean.Meta.Grind.ParentSet.mk | Lean.Meta.Tactic.Grind.Types | List Lean.Expr → Lean.Meta.Grind.ParentSet | true |
Monoid.CoprodI.NeWord.head.eq_2 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] (x x_1 j k : ι) (_hne : j ≠ k)
(w₁ : Monoid.CoprodI.NeWord M x j) (w₂ : Monoid.CoprodI.NeWord M k x_1), (w₁.append _hne w₂).head = w₁.head | true |
UniqueProds.casesOn | Mathlib.Algebra.Group.UniqueProds.Basic | {G : Type u_1} →
[inst : Mul G] →
{motive : UniqueProds G → Sort u} →
(t : UniqueProds G) →
((uniqueMul_of_nonempty :
∀ {A B : Finset G}, A.Nonempty → B.Nonempty → ∃ a0 ∈ A, ∃ b0 ∈ B, UniqueMul A B a0 b0) →
motive ⋯) →
motive t | false |
Lean.Meta.Grind.EMatchTheoremPtr | Lean.Meta.Tactic.Grind.EMatchTheoremPtr | Type | true |
Set.Ici.coe_sup._simp_1 | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} [inst : SemilatticeSup α] {a : α} {x y : ↑(Set.Ici a)}, ↑x ⊔ ↑y = ↑(x ⊔ y) | false |
_private.Init.Data.String.Defs.0.String.utf8ByteSize_eq_zero_iff._simp_1_1 | Init.Data.String.Defs | ∀ {s t : String}, (s = t) = (s.toByteArray = t.toByteArray) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.