name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Finsupp.Internal.elabSingle₀ | Mathlib.Data.Finsupp.Notation | Lean.Elab.Term.TermElab | true |
Set.subset_insert_diff_singleton | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} (x : α) (s : Set α), s ⊆ insert x (s \ {x}) | true |
_private.Mathlib.Analysis.InnerProductSpace.Adjoint.0.LinearIsometryEquiv.conjStarAlgEquiv_ext_iff._simp_1_5 | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {R₁ : Type u_1} {R₂ : Type u_2} {R₃ : Type u_3} [inst : Semiring R₁] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃]
{σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁} [inst_3 : RingHomInvPair σ₁₂ σ₂₁] [inst_4 : RingHomInvPair σ₂₁ σ₁₂]
{σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃} [inst_5 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] {M₁ : Type u_4}
[inst_6 : TopologicalSpace M₁] [inst_7 : AddCommMonoid M₁] {M₂ : Type u_5} [inst_8 : TopologicalSpace M₂]
[inst_9 : AddCommMonoid M₂] {M₃ : Type u_6} [inst_10 : TopologicalSpace M₃] [inst_11 : AddCommMonoid M₃]
[inst_12 : Module R₁ M₁] [inst_13 : Module R₂ M₂] [inst_14 : Module R₃ M₃] (e₁₂ : M₁ ≃SL[σ₁₂] M₂)
[inst_15 : RingHomCompTriple σ₂₁ σ₁₃ σ₂₃] (f : M₂ →SL[σ₂₃] M₃) (g : M₁ →SL[σ₁₃] M₃),
(f = g.comp ↑e₁₂.symm) = (f.comp ↑e₁₂ = g) | false |
RestrictedProduct.mul_apply | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} [inst_1 : (i : ι) → Mul (R i)] [inst_2 : ∀ (i : ι), MulMemClass (S i) (R i)]
(x y : RestrictedProduct (fun i => R i) (fun i => ↑(B i)) 𝓕) (i : ι), (x * y) i = x i * y i | true |
_private.Lean.Server.References.0.Lean.Server.findModuleRefs._sparseCasesOn_1 | Lean.Server.References | {motive : Lean.Lsp.RefIdent → Sort u} →
(t : Lean.Lsp.RefIdent) →
((moduleName id : String) → motive (Lean.Lsp.RefIdent.fvar moduleName id)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Lean.Omega.instDecidableEqConstraint.decEq.match_1 | Init.Omega.Constraint | (motive : Lean.Omega.Constraint → Lean.Omega.Constraint → Sort u_1) →
(x x_1 : Lean.Omega.Constraint) →
((a : Lean.Omega.LowerBound) →
(a_1 : Lean.Omega.UpperBound) →
(b : Lean.Omega.LowerBound) →
(b_1 : Lean.Omega.UpperBound) →
motive { lowerBound := a, upperBound := a_1 } { lowerBound := b, upperBound := b_1 }) →
motive x x_1 | false |
AddMonoidHom.mker.eq_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_4}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F), AddMonoidHom.mker f = AddSubmonoid.comap f ⊥ | true |
Lean.ConstantKind._sizeOf_1 | Lean.Environment | Lean.ConstantKind → ℕ | false |
StarConvex.add_left | Mathlib.Analysis.Convex.Star | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E] {x : E} {s : Set E}, StarConvex 𝕜 x s → ∀ (z : E), StarConvex 𝕜 (z + x) ((fun x => z + x) '' s) | true |
PowerSeries.X_dvd_iff | Mathlib.RingTheory.PowerSeries.Basic | ∀ {R : Type u_1} [inst : Semiring R] {φ : PowerSeries R}, PowerSeries.X ∣ φ ↔ PowerSeries.constantCoeff φ = 0 | true |
CategoryTheory.Limits.hasFiniteWidePullbacks_of_hasFiniteLimits | Mathlib.CategoryTheory.Limits.Shapes.FiniteLimits | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteLimits C],
CategoryTheory.Limits.HasFiniteWidePullbacks C | true |
Real.lt_pow_iff_log_lt | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {x y : ℝ} {n : ℕ}, 0 < x → 0 < y → (x < y ^ n ↔ Real.log x < ↑n * Real.log y) | true |
Char.leRefl | Init.Data.Char.Lemmas | Std.Refl fun x1 x2 => x1 ≤ x2 | true |
Lean.Widget.PanelWidgetsExtEntry.ctorElim | Lean.Widget.UserWidget | {motive : Lean.Widget.PanelWidgetsExtEntry → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Widget.PanelWidgetsExtEntry) →
ctorIdx = t.ctorIdx → Lean.Widget.PanelWidgetsExtEntry.ctorElimType ctorIdx → motive t | false |
PeriodPair.not_continuousAt_weierstrassP | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ (L : PeriodPair), ∀ x ∈ L.lattice, ¬ContinuousAt L.weierstrassP x | true |
FormalMultilinearSeries.rightInv._proof_15 | Mathlib.Analysis.Analytic.Inverse | ∀ {F : Type u_1} [inst : NormedAddCommGroup F], ContinuousAdd F | false |
Ideal.Quotient.instRingQuotient | Mathlib.RingTheory.Ideal.Quotient.Defs | {R : Type u_1} → [inst : CommRing R] → (I : Ideal R) → Ring (R ⧸ I) | true |
SSet.OneTruncation₂.id_edge._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | (SimplexCategory.mk (0 + 1)).len ≤ 2 | false |
_private.Mathlib.RingTheory.FractionalIdeal.Extended.0.FractionalIdeal.extended_ne_zero._simp_1_1 | Mathlib.RingTheory.FractionalIdeal.Extended | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
{I J : FractionalIdeal S P}, (I = J) = (↑I = ↑J) | false |
IsPurelyInseparable.instNonemptyAlgHomOfPerfectField | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] [IsPurelyInseparable F E]
(L : Type u_2) [inst_4 : Field L] [PerfectField L] [inst_6 : Algebra F L], Nonempty (E →ₐ[F] L) | true |
Graph.bouquet_isLoopAt | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Type u_1} {β : Type u_2} {x : α} {e : β} (v : α) (edgeSet : Set β),
(Graph.bouquet v edgeSet).IsLoopAt e x ↔ e ∈ edgeSet ∧ x = v | true |
SSet.Truncated.ev12₂._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | ∀ {V : SSet.Truncated 2}
(φ : V.obj (Opposite.op { obj := SimplexCategory.mk 2, property := SSet.Truncated.ι0₂._proof_3 })),
V.map (SimplexCategory.Truncated.δ₂ 1 SSet.Truncated.Edge._proof_1 SSet.Truncated.Edge._proof_3).op
(V.map SSet.Truncated.δ0₂.op φ) =
V.map SSet.Truncated.ι1₂.op φ | false |
IsCoveringMapOn | Mathlib.Topology.Covering.Basic | {E : Type u_1} → {X : Type u_2} → [TopologicalSpace E] → [TopologicalSpace X] → (E → X) → Set X → Prop | true |
Lean.Grind.NatModule.mk._flat_ctor | Init.Grind.Module.Basic | {M : Type u} →
(zero : M) →
(add : M → M → M) →
(∀ (a : M), a + 0 = a) →
(∀ (a b : M), a + b = b + a) →
(∀ (a b c : M), a + b + c = a + (b + c)) →
[nsmul : SMul ℕ M] →
(∀ (a : M), 0 • a = 0) → (∀ (n : ℕ) (a : M), (n + 1) • a = n • a + a) → Lean.Grind.NatModule M | false |
CategoryTheory.ExponentiableMorphism.coev_ev_assoc | Mathlib.CategoryTheory.LocallyCartesianClosed.ExponentiableMorphism | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {I J : C} (f : I ⟶ J)
[inst_1 : CategoryTheory.ChosenPullbacksAlong f] [inst_2 : CategoryTheory.ExponentiableMorphism f]
(Y : CategoryTheory.Over I) {Z : CategoryTheory.Over J}
(h : (CategoryTheory.ExponentiableMorphism.pushforward f).obj Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.ExponentiableMorphism.coev f).app ((CategoryTheory.ExponentiableMorphism.pushforward f).obj Y))
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.ExponentiableMorphism.pushforward f).map ((CategoryTheory.ExponentiableMorphism.ev f).app Y))
h) =
h | true |
ContinuousLinearMap.isEmbedding_postcomp | Mathlib.Topology.Algebra.Module.StrongTopology | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} {𝕜₃ : Type u_3} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂]
[inst_2 : NormedField 𝕜₃] {σ : 𝕜₁ →+* 𝕜₂} {τ : 𝕜₂ →+* 𝕜₃} {ρ : 𝕜₁ →+* 𝕜₃} [inst_3 : RingHomCompTriple σ τ ρ]
{E : Type u_4} {F : Type u_5} {G : Type u_6} [inst_4 : AddCommGroup E] [inst_5 : Module 𝕜₁ E]
[inst_6 : AddCommGroup F] [inst_7 : Module 𝕜₂ F] [inst_8 : AddCommGroup G] [inst_9 : Module 𝕜₃ G]
[inst_10 : TopologicalSpace E] [inst_11 : TopologicalSpace F] [inst_12 : TopologicalSpace G]
[inst_13 : IsTopologicalAddGroup F] [inst_14 : IsTopologicalAddGroup G] (f : F →SL[τ] G),
Topology.IsEmbedding ⇑f → Topology.IsEmbedding f.comp | true |
MonoidHom.coe_prod | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} {P : Type u_5} [inst : MulOneClass M] [inst_1 : MulOneClass N] [inst_2 : MulOneClass P]
(f : M →* N) (g : M →* P), ⇑(f.prod g) = Pi.prod ⇑f ⇑g | true |
HilbertSpace._sizeOf_inst | Mathlib.Analysis.InnerProductSpace.Defs | (𝕜 : Type u_4) →
(E : Type u_5) →
{inst : RCLike 𝕜} →
{inst_1 : NormedAddCommGroup E} →
{inst_2 : InnerProductSpace 𝕜 E} →
{inst_3 : CompleteSpace E} → [SizeOf 𝕜] → [SizeOf E] → SizeOf (HilbertSpace 𝕜 E) | false |
MeasureTheory.SimpleFunc.sup_eq_map₂ | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : Max β] (f g : MeasureTheory.SimpleFunc α β),
f ⊔ g = MeasureTheory.SimpleFunc.map (fun p => p.1 ⊔ p.2) (f.pair g) | true |
ModuleCat.extendRestrictScalarsAdj | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | {R : Type u₁} →
{S : Type u₂} →
[inst : CommRing R] →
[inst_1 : CommRing S] → (f : R →+* S) → ModuleCat.extendScalars f ⊣ ModuleCat.restrictScalars f | true |
Algebra.SubmersivePresentation.cotangentEquiv_apply | Mathlib.RingTheory.Smooth.StandardSmoothCotangent | ∀ {R : Type u_1} {S : Type u_2} {ι : Type u_3} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : Finite σ] (P : Algebra.SubmersivePresentation R S ι σ) (a : P.toExtension.Cotangent)
(a_1 : σ), P.cotangentEquiv a a_1 = P.cotangentComplexAux a a_1 | true |
Nat.log_pos_iff._simp_1 | Mathlib.Data.Nat.Log | ∀ {b n : ℕ}, (0 < Nat.log b n) = (b ≤ n ∧ 1 < b) | false |
Std.Slice.forIn_iter | Std.Data.Iterators.Lemmas.Producers.Slice | ∀ {α : Type v} {γ : Type u} {β : Type v} {m : Type w → Type x} [inst : Monad m] {δ : Type w}
[inst_1 : Std.ToIterator (Std.Slice γ) Id α β] [inst_2 : Std.Iterator α Id β] [inst_3 : Std.IteratorLoop α Id m]
{s : Std.Slice γ} {init : δ} {f : β → δ → m (ForInStep δ)}, forIn s.iter init f = forIn s init f | true |
OreLocalization.instDivisionRingNonZeroDivisors._proof_3 | Mathlib.RingTheory.OreLocalization.Ring | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : Nontrivial R] [inst_2 : NoZeroDivisors R]
[inst_3 : OreLocalization.OreSet (nonZeroDivisors R)] (a b : OreLocalization (nonZeroDivisors R) R), a / b = a * b⁻¹ | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.maxKey_eq_maxKeyD._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
_private.Mathlib.Topology.MetricSpace.HausdorffDistance.0.Metric.infEDist_eq_top_iff._simp_1_1 | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} {s : Set α}, s.Nonempty → (s = ∅) = False | false |
Std.TreeSet.Raw.toList_iter | Std.Data.TreeSet.Raw.Iterator | ∀ {α : Type u_1} {cmp : α → α → Ordering} (m : Std.TreeSet.Raw α cmp), m.iter.toList = m.toList | true |
add_tsub_cancel_left | Mathlib.Algebra.Order.Sub.Defs | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [OrderedSub α]
[AddLeftReflectLE α] (a b : α), a + b - a = b | true |
CategoryTheory.Lax.OplaxTrans.LaxFunctor.bicategory._proof_6 | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Lax | ∀ (B : Type u_5) [inst : CategoryTheory.Bicategory B] (C : Type u_6) [inst_1 : CategoryTheory.Bicategory C]
{a b : CategoryTheory.LaxFunctor B C} {f g : a ⟶ b} (η : f ⟶ g),
CategoryTheory.Lax.OplaxTrans.whiskerLeft (CategoryTheory.CategoryStruct.id a) η =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Lax.OplaxTrans.leftUnitor f).hom
(CategoryTheory.CategoryStruct.comp η (CategoryTheory.Lax.OplaxTrans.leftUnitor g).inv) | false |
Submodule.sndEquiv_symm_apply_coe | Mathlib.LinearAlgebra.Prod | ∀ (R : Type u) (M : Type v) (M₂ : Type w) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂] (n : M₂), ↑((Submodule.sndEquiv R M M₂).symm n) = (0, n) | true |
Set.card_empty | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u}, Fintype.card ↑∅ = 0 | true |
CategoryTheory.Pretriangulated.Triangle.instSMulHom | Mathlib.CategoryTheory.Triangulated.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.HasShift C ℤ] →
{T₁ T₂ : CategoryTheory.Pretriangulated.Triangle C} →
[inst_2 : CategoryTheory.Preadditive C] →
{R : Type u_1} →
[inst_3 : Semiring R] →
[inst_4 : CategoryTheory.Linear R C] →
[∀ (n : ℤ), CategoryTheory.Functor.Linear R (CategoryTheory.shiftFunctor C n)] → SMul R (T₁ ⟶ T₂) | true |
Lean.Server.Test.Runner.Client.InteractiveGoalCore.type | Lean.Server.Test.Runner | Lean.Server.Test.Runner.Client.InteractiveGoalCore → Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.SubexprInfo | true |
AddUnits.instAddZeroClass | Mathlib.Algebra.Group.Units.Defs | {α : Type u} → [inst : AddMonoid α] → AddZeroClass (AddUnits α) | true |
Lean.Meta.Context.localInstances._default | Lean.Meta.Basic | Array Lean.LocalInstance | false |
MeromorphicAt.meromorphicTrailingCoeffAt_of_order_eq_top | Mathlib.Analysis.Meromorphic.TrailingCoefficient | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {x : 𝕜}, meromorphicOrderAt f x = ⊤ → meromorphicTrailingCoeffAt f x = 0 | true |
Subsemigroup.isClosed_topologicalClosure | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Semigroup M] [inst_2 : SeparatelyContinuousMul M]
(s : Subsemigroup M), IsClosed ↑s.topologicalClosure | true |
_private.Mathlib.Algebra.Module.LocalizedModule.Basic.0.LocalizedModule.add_smul_aux | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u} [inst : CommSemiring R] {S : Submonoid R} {M : Type v} [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{T : Type u_1} [inst_3 : CommSemiring T] [inst_4 : Algebra R T] [inst_5 : IsLocalization S T] (x y : T)
(p : LocalizedModule S M), (x + y) • p = x • p + y • p | true |
Std.HashMap.Raw.mem_modify | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [inst_2 : EquivBEq α]
[LawfulHashable α] {k k' : α} {f : β → β}, m.WF → (k' ∈ m.modify k f ↔ k' ∈ m) | true |
EReal.toReal_zero | Mathlib.Data.EReal.Basic | EReal.toReal 0 = 0 | true |
Ordinal.aleph0_le_cof_iff._simp_1 | Mathlib.SetTheory.Cardinal.Cofinality | ∀ {o : Ordinal.{u_1}}, (Cardinal.aleph0 ≤ o.cof) = (1 < o.cof) | false |
Partrec.sumCasesOn_right | Mathlib.Computability.Partrec | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {σ : Type u_4} [inst : Primcodable α] [inst_1 : Primcodable β]
[inst_2 : Primcodable γ] [inst_3 : Primcodable σ] {f : α → β ⊕ γ} {g : α → β → σ} {h : α → γ →. σ},
Computable f → Computable₂ g → Partrec₂ h → Partrec fun a => Sum.casesOn (f a) (fun b => Part.some (g a b)) (h a) | true |
HomologicalComplex₂.ιTotalOrZero | Mathlib.Algebra.Homology.TotalComplex | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{I₁ : Type u_2} →
{I₂ : Type u_3} →
{I₁₂ : Type u_4} →
{c₁ : ComplexShape I₁} →
{c₂ : ComplexShape I₂} →
(K : HomologicalComplex₂ C c₁ c₂) →
(c₁₂ : ComplexShape I₁₂) →
[inst_2 : TotalComplexShape c₁ c₂ c₁₂] →
[inst_3 : DecidableEq I₁₂] →
[inst_4 : K.HasTotal c₁₂] →
(i₁ : I₁) → (i₂ : I₂) → (i₁₂ : I₁₂) → (K.X i₁).X i₂ ⟶ (K.total c₁₂).X i₁₂ | true |
_private.Mathlib.Computability.TuringMachine.ToPartrec.0.Turing.PartrecToTM2.trPosNum.match_1.eq_2 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (motive : PosNum → Sort u_1) (n : PosNum) (h_1 : Unit → motive PosNum.one) (h_2 : (n : PosNum) → motive n.bit0)
(h_3 : (n : PosNum) → motive n.bit1),
(match n.bit0 with
| PosNum.one => h_1 ()
| n.bit0 => h_2 n
| n.bit1 => h_3 n) =
h_2 n | true |
Std.Roi.mem_succ_iff | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LT α] [inst_1 : Std.PRange.UpwardEnumerable α] [Std.PRange.LinearlyUpwardEnumerable α]
[Std.PRange.LawfulUpwardEnumerableLT α] [inst_4 : Std.PRange.InfinitelyUpwardEnumerable α] [Std.Rxi.IsAlwaysFinite α]
[Std.PRange.LawfulUpwardEnumerable α] {lo a : α},
a ∈ (Std.PRange.succ lo)<...* ↔ ∃ a', a = Std.PRange.succ a' ∧ a' ∈ lo<...* | true |
ball_add_ball | Mathlib.Analysis.Normed.Module.Ball.Pointwise | ∀ {E : Type u_2} [inst : SeminormedAddCommGroup E] [NormedSpace ℝ E] {δ ε : ℝ},
0 < ε → 0 < δ → ∀ (a b : E), Metric.ball a ε + Metric.ball b δ = Metric.ball (a + b) (ε + δ) | true |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality.0.groupHomology.mapShortComplexH1._simp_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : Group G] [inst_2 : DivisionMonoid H]
[MonoidHomClass F G H] (f : F) (a : G), (f a)⁻¹ = f a⁻¹ | false |
ProbabilityTheory.Kernel.lintegral_piecewise | Mathlib.Probability.Kernel.Basic | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ η : ProbabilityTheory.Kernel α β}
{s : Set α} {hs : MeasurableSet s} [inst : DecidablePred fun x => x ∈ s] (a : α) (g : β → ENNReal),
∫⁻ (b : β), g b ∂(ProbabilityTheory.Kernel.piecewise hs κ η) a =
if a ∈ s then ∫⁻ (b : β), g b ∂κ a else ∫⁻ (b : β), g b ∂η a | true |
CategoryTheory.Comonad.id_δ_app | Mathlib.CategoryTheory.Monad.Basic | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (X : C),
(CategoryTheory.Comonad.id C).δ.app X = CategoryTheory.CategoryStruct.id X | true |
SuccOrder.limitRecOn_succ_of_not_isMax | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {b : α} {motive : α → Sort u_2} [inst : LinearOrder α] [inst_1 : SuccOrder α]
[inst_2 : WellFoundedLT α] (isMin : (a : α) → IsMin a → motive a)
(succ : (a : α) → ¬IsMax a → motive a → motive (Order.succ a))
(isSuccLimit : (a : α) → Order.IsSuccLimit a → ((b : α) → b < a → motive b) → motive a) (hb : ¬IsMax b),
SuccOrder.limitRecOn (Order.succ b) isMin succ isSuccLimit = succ b hb (SuccOrder.limitRecOn b isMin succ isSuccLimit) | true |
CategoryTheory.Triangulated.TStructure.noConfusion | Mathlib.CategoryTheory.Triangulated.TStructure.Basic | {P : Sort u} →
{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 : CategoryTheory.Triangulated.TStructure C} →
{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' : CategoryTheory.Triangulated.TStructure C'} →
C = C' →
inst ≍ inst' →
inst_1 ≍ inst'_1 →
inst_2 ≍ inst'_2 →
inst_3 ≍ inst'_3 →
inst_4 ≍ inst'_4 →
inst_5 ≍ inst'_5 →
t ≍ t' → CategoryTheory.Triangulated.TStructure.noConfusionType P t t' | false |
OrderRingHom.coe_orderAddMonoidHom_id | Mathlib.Algebra.Order.Hom.Ring | ∀ {α : Type u_2} [inst : NonAssocSemiring α] [inst_1 : Preorder α], ↑(OrderRingHom.id α) = OrderAddMonoidHom.id α | true |
Std.HashMap.Raw.getD_emptyWithCapacity | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {a : α} {fallback : β} {c : ℕ},
(Std.HashMap.Raw.emptyWithCapacity c).getD a fallback = fallback | true |
Finset.prod_congr_of_eq_on_inter | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_5} {M : Type u_6} {s₁ s₂ : Finset ι} {f g : ι → M} [inst : CommMonoid M],
(∀ a ∈ s₁, a ∉ s₂ → f a = 1) →
(∀ a ∈ s₂, a ∉ s₁ → g a = 1) → (∀ a ∈ s₁, a ∈ s₂ → f a = g a) → ∏ a ∈ s₁, f a = ∏ a ∈ s₂, g a | true |
NonUnitalStarAlgebra.adjoin_induction | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ (R : Type u) {A : Type v} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : NonUnitalSemiring A]
[inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : IsScalarTower R A A] [inst_6 : SMulCommClass R A A]
[inst_7 : StarModule R A] {s : Set A} {p : (x : A) → x ∈ NonUnitalStarAlgebra.adjoin R s → Prop},
(∀ (x : A) (hx : x ∈ s), p x ⋯) →
(∀ (x y : A) (hx : x ∈ NonUnitalStarAlgebra.adjoin R s) (hy : y ∈ NonUnitalStarAlgebra.adjoin R s),
p x hx → p y hy → p (x + y) ⋯) →
p 0 ⋯ →
(∀ (x y : A) (hx : x ∈ NonUnitalStarAlgebra.adjoin R s) (hy : y ∈ NonUnitalStarAlgebra.adjoin R s),
p x hx → p y hy → p (x * y) ⋯) →
(∀ (r : R) (x : A) (hx : x ∈ NonUnitalStarAlgebra.adjoin R s), p x hx → p (r • x) ⋯) →
(∀ (x : A) (hx : x ∈ NonUnitalStarAlgebra.adjoin R s), p x hx → p (star x) ⋯) →
∀ {a : A} (ha : a ∈ NonUnitalStarAlgebra.adjoin R s), p a ha | true |
FirstOrder.Language.closedUnder_univ | Mathlib.ModelTheory.Substructures | ∀ (L : FirstOrder.Language) {M : Type w} [inst : L.Structure M] {n : ℕ} (f : L.Functions n),
FirstOrder.Language.ClosedUnder f Set.univ | true |
Std.DTreeMap.Internal.Impl.isEmpty_diff_iff | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
(h₁ : m₁.WF),
m₂.WF →
((m₁.diff m₂ ⋯).isEmpty = true ↔
∀ (k : α), Std.DTreeMap.Internal.Impl.contains k m₁ = true → Std.DTreeMap.Internal.Impl.contains k m₂ = true) | true |
_private.Mathlib.Geometry.Manifold.VectorBundle.Riemannian.0.«term⟪_,_⟫» | Mathlib.Geometry.Manifold.VectorBundle.Riemannian | Lean.ParserDescr | true |
DilationEquiv.self_trans_symm | Mathlib.Topology.MetricSpace.DilationEquiv | ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y] (e : X ≃ᵈ Y),
e.trans e.symm = DilationEquiv.refl X | true |
Rat.instNormedField._proof_1 | Mathlib.Analysis.Normed.Field.Lemmas | ∀ (a b : ℚ), ‖a * b‖ = ‖a‖ * ‖b‖ | false |
CStarMatrix.mul_zero | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_5} {o : Type u_7} [inst : Fintype n] [inst_1 : NonUnitalNonAssocSemiring A]
(M : CStarMatrix m n A), M * 0 = 0 | true |
hahnEmbedding_isOrderedAddMonoid | Mathlib.RingTheory.HahnSeries.HahnEmbedding | ∀ (M : Type u_1) [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M],
∃ f,
Function.Injective ⇑f ∧
∀ (a : M), ArchimedeanClass.mk a = (FiniteArchimedeanClass.withTopOrderIso M) (ofLex (f a)).orderTop | true |
Lean.Doc.Parser.UnorderedListType.asterisk.elim | Lean.DocString.Parser | {motive : Lean.Doc.Parser.UnorderedListType → Sort u} →
(t : Lean.Doc.Parser.UnorderedListType) → t.ctorIdx = 0 → motive Lean.Doc.Parser.UnorderedListType.asterisk → motive t | false |
Lean.Elab.Term.GeneralizeResult.mk.sizeOf_spec | Lean.Elab.Match | ∀ (discrs : Array Lean.Elab.Term.Discr) (toClear : Array Lean.FVarId) (matchType : Lean.Expr)
(altViews : Array Lean.Elab.Term.TermMatchAltView) (refined : Bool),
sizeOf { discrs := discrs, toClear := toClear, matchType := matchType, altViews := altViews, refined := refined } =
1 + sizeOf discrs + sizeOf toClear + sizeOf matchType + sizeOf altViews + sizeOf refined | true |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.ExpLog.Basic.0.CFC.exp_log._proof_1_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.ExpLog.Basic | ∀ {A : Type u_1} [inst : NormedRing A] [inst_1 : NormedAlgebra ℝ A] [inst_2 : PartialOrder A] [NonnegSpectrumClass ℝ A]
(a : A), IsStrictlyPositive a → ∀ x ∈ spectrum ℝ a, ¬x = 0 | false |
Mathlib.Tactic.ITauto.Proof.hyp.injEq | Mathlib.Tactic.ITauto | ∀ (n n_1 : Lean.Name), (Mathlib.Tactic.ITauto.Proof.hyp n = Mathlib.Tactic.ITauto.Proof.hyp n_1) = (n = n_1) | true |
Lean.PrettyPrinter.Parenthesizer.term.parenthesizer._regBuiltin.Lean.PrettyPrinter.Parenthesizer.term.parenthesizer_1 | Lean.PrettyPrinter.Parenthesizer | IO Unit | false |
Option.elim'.eq_2 | Mathlib.MeasureTheory.OuterMeasure.Induced | ∀ {α : Type u_1} {β : Type u_2} (b : β) (f : α → β), Option.elim' b f none = b | true |
MonoidHom.inverse._proof_4 | Mathlib.Algebra.Group.Hom.Defs | ∀ {A : Type u_1} {B : Type u_2} [inst : Monoid A] [inst_1 : Monoid B] (f : A →* B) (g : B → A)
(h₁ : Function.LeftInverse g ⇑f) (h₂ : Function.RightInverse g ⇑f) (x y : B),
((↑f).inverse g h₁ h₂).toFun (x * y) = ((↑f).inverse g h₁ h₂).toFun x * ((↑f).inverse g h₁ h₂).toFun y | false |
Lean.Elab.Term.Arg._sizeOf_inst | Lean.Elab.Arg | SizeOf Lean.Elab.Term.Arg | false |
_private.Aesop.Search.Expansion.Basic.0.Aesop.runRuleTac.match_6 | Aesop.Search.Expansion.Basic | (motive : Except Lean.Exception Aesop.RuleTacOutput → Sort u_1) →
(result : Except Lean.Exception Aesop.RuleTacOutput) →
((ruleOutput : Aesop.RuleTacOutput) → motive (Except.ok ruleOutput)) →
((x : Except Lean.Exception Aesop.RuleTacOutput) → motive x) → motive result | false |
Lean.Firefox.ResourceTable.mk._flat_ctor | Lean.Util.Profiler | Array Lean.Json → ℕ → Lean.Firefox.ResourceTable | false |
LinearMap.fst_surjective | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {M₂ : Type w} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂], Function.Surjective ⇑(LinearMap.fst R M M₂) | true |
ENNReal.add_sub_add_eq_sub_right | Mathlib.Data.ENNReal.Operations | ∀ {a b c : ENNReal}, autoParam (c ≠ ⊤) ENNReal.add_sub_add_eq_sub_right._auto_1 → a + c - (b + c) = a - b | true |
ContinuousMap.nnnorm_sum_eq_sup | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] {R : Type u_4}
[inst_2 : NonUnitalSeminormedRing R] [IsCancelMulZero R] {ι : Type u_5} {f : ι → C(α, R)} (s : Finset ι),
Pairwise (Function.onFun (fun x1 x2 => x1 * x2 = 0) f) → ‖∑ i ∈ s, f i‖₊ = s.sup fun x => ‖f x‖₊ | true |
Matrix.replicateCol_smul | Mathlib.LinearAlgebra.Matrix.RowCol | ∀ {m : Type u_2} {R : Type u_5} {α : Type v} {ι : Type u_6} [inst : SMul R α] (x : R) (v : m → α),
Matrix.replicateCol ι (x • v) = x • Matrix.replicateCol ι v | true |
Algebra.coe_inf | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (S T : Subalgebra R A),
↑(S ⊓ T) = ↑S ∩ ↑T | true |
AddEquiv.module._proof_4 | Mathlib.Algebra.Module.TransferInstance | ∀ {α : Type u_1} {β : Type u_3} (A : Type u_2) [inst : Semiring A] [inst_1 : AddCommMonoid α] [inst_2 : AddCommMonoid β]
[inst_3 : Module A β] (e : α ≃+ β) (a : A) (x y : α), a • (x + y) = a • x + a • y | false |
_private.Mathlib.AlgebraicTopology.ModelCategory.Basic.0.HomotopicalAlgebra.ModelCategory.mk'.cm3a_aux._simp_1_4 | Mathlib.AlgebraicTopology.ModelCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C],
HomotopicalAlgebra.WeakEquivalence f = HomotopicalAlgebra.weakEquivalences C f | false |
_private.Mathlib.Algebra.Star.Subalgebra.0.StarSubalgebra.mem_centralizer_iff._simp_1_2 | Mathlib.Algebra.Star.Subalgebra | ∀ {α : Type u_1} {s : Set α} [inst : InvolutiveStar α], star s = star '' s | false |
EReal.div_pos | Mathlib.Data.EReal.Inv | ∀ {a b : EReal}, 0 < a → 0 < b → b ≠ ⊤ → 0 < a / b | true |
_private.Mathlib.SetTheory.Lists.0.Lists.mem.decidable.match_1.eq_2 | Mathlib.SetTheory.Lists | ∀ {α : Type u_1} (motive : Lists α → Lists' α true → Sort u_2) (a : Lists α) (b : Bool) (b_1 : Lists' α b)
(l₂ : Lists' α true) (h_1 : (a : Lists α) → motive a Lists'.nil)
(h_2 : (a : Lists α) → (b : Bool) → (b_2 : Lists' α b) → (l₂ : Lists' α true) → motive a (b_2.cons' l₂)),
(match a, b_1.cons' l₂ with
| a, Lists'.nil => h_1 a
| a, b_2.cons' l₂ => h_2 a b b_2 l₂) =
h_2 a b b_1 l₂ | true |
CategoryTheory.Retract.ofIso._proof_2 | Mathlib.CategoryTheory.Retract | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (e : X ≅ Y),
CategoryTheory.CategoryStruct.comp e.hom e.inv = CategoryTheory.CategoryStruct.id X | false |
Submodule.eq_of_le_of_finrank_le | Mathlib.LinearAlgebra.FiniteDimensional.Basic | ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
{S₁ S₂ : Submodule K V} [FiniteDimensional K ↥S₂], S₁ ≤ S₂ → Module.finrank K ↥S₂ ≤ Module.finrank K ↥S₁ → S₁ = S₂ | true |
AlgebraicGeometry.Scheme.Pullback.openCoverOfRight._proof_3 | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : Y.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z) (i : 𝒰.I₀),
CategoryTheory.Limits.HasPullback f (CategoryTheory.CategoryStruct.comp (𝒰.f i) g) | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.signExtend_extractLsb_setWidth._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w n : ℕ} (i : ℕ), n + i < w → ¬n + i < w + n → False | false |
Int.Linear.orOver_cases | Init.Data.Int.Linear | ∀ {n : ℕ} {p : ℕ → Prop}, Int.Linear.OrOver (n + 1) p → Int.Linear.OrOver_cases_type n p | true |
TensorProduct.uniqueLeft._proof_3 | Mathlib.LinearAlgebra.TensorProduct.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} {N : Type u_3} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] [Subsingleton M] (z : TensorProduct R M N),
z = 0 | false |
closedBall_add_singleton | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] (δ : ℝ) (x y : E),
Metric.closedBall x δ + {y} = Metric.closedBall (x + y) δ | true |
enorm_eq_zero'._simp_2 | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_8} [inst : TopologicalSpace E] [inst_1 : ENormedMonoid E] {a : E}, (‖a‖ₑ = 0) = (a = 1) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.