name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Std.ExtTreeMap.diff.congr_simp | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] (t₁ t₁_1 : Std.ExtTreeMap α β cmp),
t₁ = t₁_1 → ∀ (t₂ t₂_1 : Std.ExtTreeMap α β cmp), t₂ = t₂_1 → t₁.diff t₂ = t₁_1.diff t₂_1 |
BoundedContinuousFunction.instFunLike | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] → [inst_1 : PseudoMetricSpace β] → FunLike (BoundedContinuousFunction α β) α β |
CategoryTheory.Sheaf.isLocallySurjective_comp | Mathlib.CategoryTheory.Sites.LocallySurjective | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u'}
[inst_1 : CategoryTheory.Category.{v', u'} A] {FA : A → A → Type u_1} {CA : A → Type w'}
[inst_2 : (X Y : A) → FunLike (FA X Y) (CA X) (CA Y)] [inst_3 : CategoryTheory.ConcreteCategory A FA]
{F₁ F₂ F₃ : CategoryTheory.Sheaf J A} (φ : F₁ ⟶ F₂) (ψ : F₂ ⟶ F₃) [CategoryTheory.Sheaf.IsLocallySurjective φ]
[CategoryTheory.Sheaf.IsLocallySurjective ψ],
CategoryTheory.Sheaf.IsLocallySurjective (CategoryTheory.CategoryStruct.comp φ ψ) |
unitInterval.sigmoid._proof_1 | Mathlib.Analysis.SpecialFunctions.Sigmoid | ∀ (x : ℝ), 0 ≤ x.sigmoid ∧ x.sigmoid ≤ 1 |
CategoryTheory.FreeBicategory.Hom₂.whisker_right | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u} →
[inst : Quiver B] →
{a b c : CategoryTheory.FreeBicategory B} →
{f g : a ⟶ b} →
(h : b ⟶ c) →
CategoryTheory.FreeBicategory.Hom₂ f g →
CategoryTheory.FreeBicategory.Hom₂ (CategoryTheory.FreeBicategory.Hom.comp f h)
(CategoryTheory.FreeBicategory.Hom.comp g h) |
Lean.Core.instMonadLogCoreM | Lean.CoreM | Lean.MonadLog Lean.CoreM |
Algebra.trdeg | Mathlib.RingTheory.AlgebraicIndependent.Basic | (R : Type u_2) → (A : Type v) → [inst : CommRing R] → [inst_1 : CommRing A] → [Algebra R A] → Cardinal.{v} |
Function.Involutive.rightInverse | Mathlib.Logic.Function.Basic | ∀ {α : Sort u} {f : α → α}, Function.Involutive f → Function.RightInverse f f |
CliffordAlgebra.evenEquivEvenNeg._proof_1 | Mathlib.LinearAlgebra.CliffordAlgebra.EvenEquiv | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M), -Q = -Q |
smul_le_smul_iff_of_pos_left._simp_1 | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} {a : α} {b₁ b₂ : β} [inst : SMul α β] [inst_1 : Preorder α] [inst_2 : Preorder β]
[inst_3 : Zero α] [PosSMulMono α β] [PosSMulReflectLE α β], 0 < a → (a • b₁ ≤ a • b₂) = (b₁ ≤ b₂) |
CategoryTheory.GradedObject.single_map_singleObjApplyIsoOfEq_hom | Mathlib.CategoryTheory.GradedObject.Single | ∀ {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_2} C]
[inst_1 : CategoryTheory.Limits.HasInitial C] [inst_2 : DecidableEq J] (j : J) {X Y : C} (f : X ⟶ Y) (i : J)
(h : i = j),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.GradedObject.single j).map f i)
(CategoryTheory.GradedObject.singleObjApplyIsoOfEq j Y i h).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.singleObjApplyIsoOfEq j X i h).hom f |
Lean.Grind.NatModule.one_nsmul | Init.Grind.Module.Basic | ∀ {M : Type u} [inst : Lean.Grind.NatModule M] (a : M), 1 • a = a |
Module.Basis.constr_def | Mathlib.LinearAlgebra.Basis.Defs | ∀ {M' : Type u_7} [inst : AddCommMonoid M'] {ι : Type u_10} {R : Type u_11} {M : Type u_12} [inst_1 : Semiring R]
[inst_2 : AddCommMonoid M] [inst_3 : Module R M] (b : Module.Basis ι R M) [inst_4 : Module R M'] (S : Type u_13)
[inst_5 : Semiring S] [inst_6 : Module S M'] [inst_7 : SMulCommClass R S M'] (f : ι → M'),
(b.constr S) f = Finsupp.linearCombination R id ∘ₗ Finsupp.lmapDomain R R f ∘ₗ ↑b.repr |
CategoryTheory.TransfiniteCompositionOfShape.ofComposableArrows_F | Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {n : ℕ} (G : CategoryTheory.ComposableArrows C n),
(CategoryTheory.TransfiniteCompositionOfShape.ofComposableArrows G).F = G |
_private.Mathlib.Geometry.Euclidean.Inversion.ImageHyperplane.0.EuclideanGeometry.inversion_mem_perpBisector_inversion_iff._simp_1_7 | Mathlib.Geometry.Euclidean.Inversion.ImageHyperplane | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False |
AddChar.coe_compAddMonoidHom._simp_1 | Mathlib.Algebra.Group.AddChar | ∀ {A : Type u_1} {B : Type u_2} {M : Type u_3} [inst : AddMonoid A] [inst_1 : AddMonoid B] [inst_2 : Monoid M]
(φ : AddChar B M) (f : A →+ B), ⇑φ ∘ ⇑f = ⇑(φ.compAddMonoidHom f) |
CategoryTheory.MonoidalOpposite.mopMopEquivalenceFunctorMonoidal._proof_12 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X Y : Cᴹᵒᵖᴹᵒᵖ} (f : X ⟶ Y) (X' : Cᴹᵒᵖᴹᵒᵖ),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.id
((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).functor.obj
(CategoryTheory.MonoidalCategoryStruct.tensorObj X X')))
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).functor.map f)
((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).functor.obj X')) =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).functor.map
(CategoryTheory.MonoidalCategoryStruct.whiskerRight f X'))
(CategoryTheory.CategoryStruct.id
((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).functor.obj
(CategoryTheory.MonoidalCategoryStruct.tensorObj Y X'))) |
Lean.Meta.Grind.Split.instInhabitedState | Lean.Meta.Tactic.Grind.Types | Inhabited Lean.Meta.Grind.Split.State |
Std.Roo.forIn'_congr | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerableLT α] [inst_4 : Std.Rxo.IsAlwaysFinite α]
[inst_5 : Std.PRange.LawfulUpwardEnumerable α] {m : Type u → Type w} [inst_6 : Monad m] {γ : Type u} {init init' : γ}
{r r' : Std.Roo α} {f : (a : α) → a ∈ r → γ → m (ForInStep γ)} {f' : (a : α) → a ∈ r' → γ → m (ForInStep γ)}
(hr : r = r'),
init = init' → (∀ (a : α) (m_1 : a ∈ r') (b : γ), f a ⋯ b = f' a m_1 b) → forIn' r init f = forIn' r' init' f' |
controlled_closure_range_of_complete | Mathlib.Analysis.Normed.Group.ControlledClosure | ∀ {G : Type u_1} [inst : NormedAddCommGroup G] [CompleteSpace G] {H : Type u_2} [inst_2 : NormedAddCommGroup H]
{f : NormedAddGroupHom G H} {K : Type u_3} [inst_3 : SeminormedAddCommGroup K] {j : NormedAddGroupHom K H},
(∀ (x : K), ‖j x‖ = ‖x‖) →
∀ {C ε : ℝ},
0 < C →
0 < ε → (∀ (k : K), ∃ g, f g = j k ∧ ‖g‖ ≤ C * ‖k‖) → f.SurjectiveOnWith j.range.topologicalClosure (C + ε) |
Int.closedBall_eq_Icc | Mathlib.Topology.Instances.Int | ∀ (x : ℤ) (r : ℝ), Metric.closedBall x r = Set.Icc ⌈↑x - r⌉ ⌊↑x + r⌋ |
BitVec.getLsbD_ofNatLT | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} (x : ℕ) (lt : x < 2 ^ n) (i : ℕ), (x#'lt).getLsbD i = x.testBit i |
Fin.get_take_eq_take_get_comp_cast | Mathlib.Data.Fin.Tuple.Take | ∀ {α : Type u_2} {m : ℕ} (l : List α) (h : m ≤ l.length), (List.take m l).get = Fin.take m h l.get ∘ Fin.cast ⋯ |
Filter.frequently_true_iff_neBot._simp_1 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} (f : Filter α), (∃ᶠ (x : α) in f, True) = f.NeBot |
IsOfFinOrder.unit.eq_1 | Mathlib.GroupTheory.OrderOfElement | ∀ {M : Type u_6} [inst : Monoid M] {x : M} (hx : IsOfFinOrder x),
hx.unit = { val := x, inv := x ^ (orderOf x - 1), val_inv := ⋯, inv_val := ⋯ } |
CategoryTheory.MonoidalCategoryStruct.rightUnitor | Mathlib.CategoryTheory.Monoidal.Category | {C : Type u} →
{𝒞 : CategoryTheory.Category.{v, u} C} →
[self : CategoryTheory.MonoidalCategoryStruct C] →
(X : C) →
CategoryTheory.MonoidalCategoryStruct.tensorObj X (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) ≅ X |
CategoryTheory.Functor.toCostructuredArrow._proof_2 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {E : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} E]
(G : CategoryTheory.Functor E C) (F : CategoryTheory.Functor C D) (X : D) (f : (Y : E) → F.obj (G.obj Y) ⟶ X)
(h : ∀ {Y Z : E} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (F.map (G.map g)) (f Z) = f Y) (X_1 : E),
CategoryTheory.CostructuredArrow.homMk (G.map (CategoryTheory.CategoryStruct.id X_1)) ⋯ =
CategoryTheory.CategoryStruct.id (CategoryTheory.CostructuredArrow.mk (f X_1)) |
Std.ExtHashSet.getD_eq_fallback_of_contains_eq_false | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{a fallback : α}, m.contains a = false → m.getD a fallback = fallback |
Mathlib.Tactic.BicategoryLike.Mor₂Iso.isStructural._unsafe_rec | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | Mathlib.Tactic.BicategoryLike.Mor₂Iso → Bool |
MeasureTheory.Egorov.notConvergentSeq_antitone | Mathlib.MeasureTheory.Function.Egorov | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : PseudoEMetricSpace β] {n : ℕ} {f : ι → α → β} {g : α → β}
[inst_1 : Preorder ι], Antitone (MeasureTheory.Egorov.notConvergentSeq f g n) |
_private.Init.Data.SInt.Lemmas.0.ISize.toInt_ofNat_of_lt_two_pow_numBits._proof_1_1 | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, n < 2147483648 → ¬↑n < 2147483648 → False |
_private.Mathlib.LinearAlgebra.Semisimple.0.LinearEquiv.isSemisimple_iff._simp_1_2 | Mathlib.LinearAlgebra.Semisimple | ∀ (R : Type u_2) [inst : Ring R] (M : Type u_4) [inst_1 : AddCommGroup M] [inst_2 : Module R M],
IsSemisimpleModule R M = ComplementedLattice (Submodule R M) |
Fin.lt_sub_iff | Mathlib.Algebra.Group.Fin.Basic | ∀ {n : ℕ} {a b : Fin n}, a < a - b ↔ a < b |
Function.Injective | Init.Data.Function | {α : Sort u_1} → {β : Sort u_2} → (α → β) → Prop |
Lean.Parser.Term.subst._regBuiltin.Lean.Parser.Term.subst.formatter_9 | Lean.Parser.Term | IO Unit |
Set.pairwise_iUnion₂ | Mathlib.Data.Set.Pairwise.Lattice | ∀ {α : Type u_1} {s : Set (Set α)},
DirectedOn (fun x1 x2 => x1 ⊆ x2) s → ∀ (r : α → α → Prop), (∀ a ∈ s, a.Pairwise r) → (⋃ a ∈ s, a).Pairwise r |
CategoryTheory.ObjectProperty.preservesLimit_iff | Mathlib.CategoryTheory.ObjectProperty.FunctorCategory.PreservesLimits | ∀ {J : Type u_1} {C : Type u_3} (K : Type u_5) [inst : CategoryTheory.Category.{v_1, u_5} K]
[inst_1 : CategoryTheory.Category.{v_3, u_1} J] [inst_2 : CategoryTheory.Category.{v_5, u_3} C]
(F : CategoryTheory.Functor K J) (G : CategoryTheory.Functor J C),
CategoryTheory.ObjectProperty.preservesLimit F G ↔ CategoryTheory.Limits.PreservesLimit F G |
CategoryTheory.Limits.IsLimit.ofIsZero | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} D] →
[CategoryTheory.Limits.HasZeroMorphisms C] →
[CategoryTheory.Limits.HasZeroObject C] →
{F : CategoryTheory.Functor D C} →
(c : CategoryTheory.Limits.Cone F) →
CategoryTheory.Limits.IsZero F → CategoryTheory.Limits.IsZero c.pt → CategoryTheory.Limits.IsLimit c |
_private.Mathlib.Data.Nat.Totient.0.Mathlib.Meta.Positivity.evalNatTotient.match_4 | Mathlib.Data.Nat.Totient | (motive :
(u : Lean.Level) →
{α : Q(Type u)} →
(z : Q(Zero «$α»)) →
(p : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness z p e) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness z p e) → Sort u_1) →
(u : Lean.Level) →
{α : Q(Type u)} →
(z : Q(Zero «$α»)) →
(p : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_1 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness z p e)) →
((α : Q(Type)) →
(z : Q(Zero «$α»)) →
(p : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_2 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness z p e)) →
motive Lean.Level.zero z p e __alt __alt_2) →
((x : Lean.Level) →
(α : Q(Type x)) →
(z : Q(Zero «$α»)) →
(p : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_2 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness z p e)) →
motive x z p e __alt __alt_2) →
motive u z p e __alt __alt_1 |
String.Slice.Pos.prevAux._proof_6 | Init.Data.String.Basic | ∀ {s : String.Slice} (off : ℕ), off + 1 < s.utf8ByteSize → off < s.utf8ByteSize |
_private.Mathlib.NumberTheory.Dioph.0.Dioph.diophFn_compn.match_1_1 | Mathlib.NumberTheory.Dioph | ∀ {α : Type} (motive : (x : ℕ) → (x_1 : Set (α ⊕ Fin2 x → ℕ)) → Dioph x_1 → Vector3 ((α → ℕ) → ℕ) x → Prop) (x : ℕ)
(x_1 : Set (α ⊕ Fin2 x → ℕ)) (x_2 : Dioph x_1) (x_3 : Vector3 ((α → ℕ) → ℕ) x),
(∀ (S : Set (α ⊕ Fin2 0 → ℕ)) (d : Dioph S) (f : Vector3 ((α → ℕ) → ℕ) 0), motive 0 S d f) →
(∀ (n : ℕ) (S : Set (α ⊕ Fin2 n.succ → ℕ)) (d : Dioph S) (f : Vector3 ((α → ℕ) → ℕ) n.succ), motive n.succ S d f) →
motive x x_1 x_2 x_3 |
Std.DTreeMap.Internal.Impl.toListModel_interSmallerFn | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} [Std.TransOrd α] [inst : BEq α] [Std.LawfulBEqOrd α]
(m sofar : Std.DTreeMap.Internal.Impl α β),
m.WF →
∀ (h₂ : sofar.WF) (l : List ((a : α) × β a)) (k : α),
sofar.toListModel.Perm l →
(↑(m.interSmallerFn ⟨sofar, ⋯⟩ k)).toListModel.Perm (Std.Internal.List.interSmallerFn m.toListModel l k) |
_private.Mathlib.Algebra.Homology.HomotopyCategory.ShiftSequence.0.CochainComplex.instShiftSequenceHomologicalComplexIntUpHomologyFunctorOfNat._simp_4 | Mathlib.Algebra.Homology.HomotopyCategory.ShiftSequence | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ S₃ : CategoryTheory.ShortComplex C} [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology]
[inst_4 : S₃.HasHomology] (φ₁ : S₁ ⟶ S₂) (φ₂ : S₂ ⟶ S₃),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.homologyMap φ₁)
(CategoryTheory.ShortComplex.homologyMap φ₂) =
CategoryTheory.ShortComplex.homologyMap (CategoryTheory.CategoryStruct.comp φ₁ φ₂) |
MonoidHom.op._proof_5 | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_2} {N : Type u_1} [inst : MulOneClass M] [inst_1 : MulOneClass N] (f : Mᵐᵒᵖ →* Nᵐᵒᵖ),
MulOpposite.unop ((⇑f ∘ MulOpposite.op) 1) = MulOpposite.unop { unop' := 1 } |
Std.DHashMap.Internal.Raw.Const.ofList_eq | Std.Data.DHashMap.Internal.Raw | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {l : List (α × β)},
Std.DHashMap.Raw.Const.ofList l =
↑↑(Std.DHashMap.Internal.Raw₀.Const.insertMany Std.DHashMap.Internal.Raw₀.emptyWithCapacity l) |
definition._@.Mathlib.MeasureTheory.Measure.Typeclasses.Finite.588747923._hygCtx._hyg.2 | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | {α : Type u_1} →
[inst : TopologicalSpace α] →
[SecondCountableTopology α] →
{m : MeasurableSpace α} →
(μ : MeasureTheory.Measure α) → [MeasureTheory.IsLocallyFiniteMeasure μ] → μ.FiniteSpanningSetsIn {K | IsOpen K} |
IsBaseChange.endHom._proof_2 | Mathlib.RingTheory.TensorProduct.IsBaseChangeHom | ∀ {S : Type u_1} [inst : CommSemiring S] {P : Type u_2} [inst_1 : AddCommMonoid P] [inst_2 : Module S P],
SMulCommClass S S (P →ₗ[S] P) |
CategoryTheory.Limits.Fan.combPairHoms | Mathlib.CategoryTheory.Limits.Shapes.CombinedProducts | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
{ι₁ : Type u_1} →
{ι₂ : Type u_2} →
{f₁ : ι₁ → C} →
{f₂ : ι₂ → C} →
(c₁ : CategoryTheory.Limits.Fan f₁) →
(c₂ : CategoryTheory.Limits.Fan f₂) →
(bc : CategoryTheory.Limits.BinaryFan c₁.pt c₂.pt) → (i : ι₁ ⊕ ι₂) → bc.pt ⟶ Sum.elim f₁ f₂ i |
Lean.Elab.Term.Quotation.elabMatchSyntax._regBuiltin.Lean.Elab.Term.Quotation.elabMatchSyntax.declRange_3 | Lean.Elab.Quotation | IO Unit |
IncidenceAlgebra.instNonAssocSemiring | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | {𝕜 : Type u_2} →
{α : Type u_5} →
[inst : Preorder α] →
[LocallyFiniteOrder α] → [DecidableEq α] → [inst_3 : NonAssocSemiring 𝕜] → NonAssocSemiring (IncidenceAlgebra 𝕜 α) |
Matrix.of_symm_apply | Mathlib.LinearAlgebra.Matrix.Defs | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} (f : Matrix m n α) (i : m) (j : n), Matrix.of.symm f i j = f i j |
Mathlib.Meta.Positivity.prod_ne_zero | Mathlib.Algebra.Order.BigOperators.Ring.Finset | ∀ {ι : Type u_1} {M₀ : Type u_4} [inst : CommMonoidWithZero M₀] {f : ι → M₀} {s : Finset ι} [Nontrivial M₀]
[NoZeroDivisors M₀], (∀ a ∈ s, f a ≠ 0) → ∏ x ∈ s, f x ≠ 0 |
instAddCancelMonoidLex | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [h : AddCancelMonoid α] → AddCancelMonoid (Lex α) |
Aesop.Iteration | Aesop.Tree.Data | Type |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.equiv_iff_toList_perm._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) |
NFA.eval | Mathlib.Computability.NFA | {α : Type u} → {σ : Type v} → NFA α σ → List α → Set σ |
Units.oneSub.eq_1 | Mathlib.Analysis.Analytic.Constructions | ∀ {R : Type u_4} [inst : NormedRing R] [inst_1 : HasSummableGeomSeries R] (t : R) (h : ‖t‖ < 1),
Units.oneSub t h = { val := 1 - t, inv := ∑' (n : ℕ), t ^ n, val_inv := ⋯, inv_val := ⋯ } |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics.0.tendsto_rpow_div_mul_add._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Ioi b) = (b < x) |
instOneMulHom._proof_1 | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_2} {N : Type u_1} [inst : MulOneClass N] (x x : M), 1 = 1 * 1 |
AddGroupExtension.quotientKerRightHomEquivRight.eq_1 | Mathlib.GroupTheory.GroupExtension.Basic | ∀ {N : Type u_1} {G : Type u_2} [inst : AddGroup N] [inst_1 : AddGroup G] {E : Type u_3} [inst_2 : AddGroup E]
(S : AddGroupExtension N E G),
S.quotientKerRightHomEquivRight = QuotientAddGroup.quotientKerEquivOfSurjective S.rightHom ⋯ |
_private.Mathlib.Algebra.Homology.ExactSequence.0.CategoryTheory.ComposableArrows.isComplex₂_iff._proof_3 | Mathlib.Algebra.Homology.ExactSequence | ¬1 ≤ 2 → False |
Lean.Elab.Term.Do.ToCodeBlock.doReassignArrowToCode | Lean.Elab.Do.Legacy | Lean.Syntax → List Lean.Syntax → Lean.Elab.Term.Do.ToCodeBlock.M Lean.Elab.Term.Do.CodeBlock |
SSet.RelativeMorphism.Homotopy.mk | Mathlib.AlgebraicTopology.SimplicialSet.RelativeMorphism | {X Y : SSet} →
{A : X.Subcomplex} →
{B : Y.Subcomplex} →
{φ : A.toSSet ⟶ B.toSSet} →
{f g : SSet.RelativeMorphism A B φ} →
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj X (SSet.stdSimplex.obj (SimplexCategory.mk 1)) ⟶ Y) →
autoParam (CategoryTheory.CategoryStruct.comp SSet.ι₀ h = f.map)
SSet.RelativeMorphism.Homotopy.h₀._autoParam →
autoParam (CategoryTheory.CategoryStruct.comp SSet.ι₁ h = g.map)
SSet.RelativeMorphism.Homotopy.h₁._autoParam →
autoParam
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight A.ι
(SSet.stdSimplex.obj (SimplexCategory.mk 1)))
h =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.SemiCartesianMonoidalCategory.fst A.toSSet
(SSet.stdSimplex.obj (SimplexCategory.mk 1)))
(CategoryTheory.CategoryStruct.comp φ B.ι))
SSet.RelativeMorphism.Homotopy.rel._autoParam →
f.Homotopy g |
MeasureTheory.Measure.MutuallySingular.compProd_of_left | Mathlib.Probability.Kernel.Composition.MeasureCompProd | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {μ ν : MeasureTheory.Measure α},
μ.MutuallySingular ν → ∀ (κ η : ProbabilityTheory.Kernel α β), (μ.compProd κ).MutuallySingular (ν.compProd η) |
_private.Mathlib.Combinatorics.SimpleGraph.Trails.0.SimpleGraph.Walk.IsTrail.even_countP_edges_iff._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Trails | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x |
WittVector.one_coeff_zero | Mathlib.RingTheory.WittVector.Defs | ∀ (p : ℕ) (R : Type u_1) [hp : Fact (Nat.Prime p)] [inst : CommRing R], WittVector.coeff 1 0 = 1 |
CategoryTheory.ShortComplex.epi_homologyMap_of_epi_cyclesMap' | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology],
CategoryTheory.Epi (CategoryTheory.ShortComplex.cyclesMap φ) →
CategoryTheory.Epi (CategoryTheory.ShortComplex.homologyMap φ) |
_private.Mathlib.Analysis.CStarAlgebra.ApproximateUnit.0.Set.InvOn.one_sub_one_add_inv._simp_1_6 | Mathlib.Analysis.CStarAlgebra.ApproximateUnit | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False |
dense_of_nonempty_smul_invariant | Mathlib.Dynamics.Minimal | ∀ (M : Type u_1) {α : Type u_3} [inst : Monoid M] [inst_1 : TopologicalSpace α] [inst_2 : MulAction M α]
[MulAction.IsMinimal M α] {s : Set α}, s.Nonempty → (∀ (c : M), c • s ⊆ s) → Dense s |
List.drop_modifyHead_of_pos | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} {f : α → α} {l : List α} {i : ℕ}, 0 < i → List.drop i (List.modifyHead f l) = List.drop i l |
div_eq_inv_self | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] {a b : G}, a / b = b⁻¹ ↔ a = 1 |
Finset.min_mem_image_coe | Mathlib.Data.Finset.Max | ∀ {α : Type u_2} [inst : LinearOrder α] {s : Finset α}, s.Nonempty → s.min ∈ Finset.image WithTop.some s |
_private.Init.Data.Rat.Lemmas.0.Rat.divInt.match_3.eq_1 | Init.Data.Rat.Lemmas | ∀ (motive : ℤ → ℤ → Sort u_1) (n : ℤ) (d : ℕ) (h_1 : (n : ℤ) → (d : ℕ) → motive n (Int.ofNat d))
(h_2 : (n : ℤ) → (d : ℕ) → motive n (Int.negSucc d)),
(match n, Int.ofNat d with
| n, Int.ofNat d => h_1 n d
| n, Int.negSucc d => h_2 n d) =
h_1 n d |
Rep.coindFunctor_map | Mathlib.RepresentationTheory.Coinduced | ∀ (k : Type u) {G H : Type u} [inst : CommRing k] [inst_1 : Monoid G] [inst_2 : Monoid H] (φ : G →* H) {X Y : Rep k G}
(f : X ⟶ Y), (Rep.coindFunctor k φ).map f = Rep.coindMap φ f |
_private.Mathlib.Algebra.Ring.Subring.Defs.0.intCast_mem._simp_1_1 | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u_1} [inst : AddGroupWithOne R] (n : ℤ), ↑n = n • 1 |
Algebra.Extension | Mathlib.RingTheory.Extension.Basic | (R : Type u) → (S : Type v) → [inst : CommRing R] → [inst_1 : CommRing S] → [Algebra R S] → Type (max (max u v) (w + 1)) |
isOfFinAddOrder_ofMul_iff | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : Monoid G] {x : G}, IsOfFinAddOrder (Additive.ofMul x) ↔ IsOfFinOrder x |
SeparationQuotient.preimage_image_mk_closed | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X},
IsClosed s → SeparationQuotient.mk ⁻¹' (SeparationQuotient.mk '' s) = s |
IsCompact.compl_mem_coclosedCompact_of_isClosed | Mathlib.Topology.Compactness.Compact | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsCompact s → IsClosed s → sᶜ ∈ Filter.coclosedCompact X |
Lean.Elab.Tactic.BVDecide.Frontend.BVDecideConfig.maxSteps._default | Std.Tactic.BVDecide.Syntax | ℕ |
ContinuousLinearEquiv.continuousAlternatingMapCongrLeft._proof_1 | Mathlib.Topology.Algebra.Module.Alternating.Topology | ∀ {𝕜 : Type u_1} {E : Type u_2} {E' : Type u_5} {F : Type u_3} {ι : Type u_4} [inst : NormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E] [inst_3 : TopologicalSpace E] [inst_4 : AddCommGroup E']
[inst_5 : Module 𝕜 E'] [inst_6 : TopologicalSpace E'] [inst_7 : AddCommGroup F] [inst_8 : Module 𝕜 F]
[inst_9 : TopologicalSpace F] [inst_10 : IsTopologicalAddGroup F] [inst_11 : ContinuousConstSMul 𝕜 F] (f : E ≃L[𝕜] E')
(x y : E [⋀^ι]→L[𝕜] F),
(↑(ContinuousAlternatingMap.compContinuousLinearMapCLM ↑f.symm)).toFun (x + y) =
(↑(ContinuousAlternatingMap.compContinuousLinearMapCLM ↑f.symm)).toFun x +
(↑(ContinuousAlternatingMap.compContinuousLinearMapCLM ↑f.symm)).toFun y |
Sigma.curry_update | Mathlib.Data.Sigma.Basic | ∀ {α : Type u_1} {β : α → Type u_4} {γ : (a : α) → β a → Type u_7} [inst : DecidableEq α]
[inst_1 : (a : α) → DecidableEq (β a)] (i : (a : α) × β a) (f : (i : (a : α) × β a) → γ i.fst i.snd)
(x : γ i.fst i.snd),
Sigma.curry (Function.update f i x) =
Function.update (Sigma.curry f) i.fst (Function.update (Sigma.curry f i.fst) i.snd x) |
Matrix.cRank_one | Mathlib.LinearAlgebra.Matrix.Rank | ∀ {m : Type um} {R : Type uR} [inst : CommRing R] [Nontrivial R] [inst_2 : DecidableEq m],
Matrix.cRank 1 = Cardinal.lift.{uR, um} (Cardinal.mk m) |
NonUnitalRing.sub._inherited_default | Mathlib.Algebra.Ring.Defs | {α : Type u_1} →
(add : α → α → α) →
(∀ (a b c : α), a + b + c = a + (b + c)) →
(zero : α) →
(∀ (a : α), 0 + a = a) →
(∀ (a : α), a + 0 = a) →
(nsmul : ℕ → α → α) →
(∀ (x : α), nsmul 0 x = 0) → (∀ (n : ℕ) (x : α), nsmul (n + 1) x = nsmul n x + x) → (α → α) → α → α → α |
ContDiff.fun_comp_contDiffOn | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : WithTop ℕ∞} {s : Set E} {g : F → G} {f : E → F},
ContDiff 𝕜 n g → ContDiffOn 𝕜 n f s → ContDiffOn 𝕜 n (fun x => g (f x)) s |
IsLowerSet.isOpen | Mathlib.Topology.Order.Basic | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [WellFoundedLT α] {s : Set α},
IsLowerSet s → IsOpen s |
_private.Mathlib.Combinatorics.SimpleGraph.Subgraph.0.SimpleGraph.Subgraph.subgraphOfAdj_eq_induce._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {α : Type u} {a b : α}, (a ∈ {b}) = (a = b) |
ProbabilityTheory.Kernel.ae_comp_of_ae_ae | Mathlib.Probability.Kernel.Composition.Comp | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} {κ : ProbabilityTheory.Kernel α β} {η : ProbabilityTheory.Kernel β γ} {a : α} {p : γ → Prop},
MeasurableSet {z | p z} → (∀ᵐ (y : β) ∂κ a, ∀ᵐ (z : γ) ∂η y, p z) → ∀ᵐ (z : γ) ∂(η.comp κ) a, p z |
_private.Mathlib.MeasureTheory.Integral.Bochner.Basic.0.Mathlib.Meta.Positivity.evalIntegral.match_1 | Mathlib.MeasureTheory.Integral.Bochner.Basic | (motive :
(u : Lean.Level) →
{α : Q(Type u)} →
(zα : Q(Zero «$α»)) →
(pα : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness zα pα e) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness zα pα e) → Sort u_1) →
(u : Lean.Level) →
{α : Q(Type u)} →
(zα : Q(Zero «$α»)) →
(pα : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_1 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness zα pα e)) →
((α : Q(Type)) →
(zα : Q(Zero «$α»)) →
(pα : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_2 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness zα pα e)) →
motive Lean.Level.zero zα pα e __alt __alt_2) →
((x : Lean.Level) →
(α : Q(Type x)) →
(zα : Q(Zero «$α»)) →
(pα : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_2 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness zα pα e)) →
motive x zα pα e __alt __alt_2) →
motive u zα pα e __alt __alt_1 |
Filter.mem_zero | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Zero α] {s : Set α}, s ∈ 0 ↔ 0 ∈ s |
Std.DTreeMap.Internal.Impl.Const.get?_union_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
(h₁ : m₁.WF) (h₂ : m₂.WF) {k : α},
Std.DTreeMap.Internal.Impl.contains k m₁ = false →
Std.DTreeMap.Internal.Impl.Const.get? (m₁.union m₂ ⋯ ⋯) k = Std.DTreeMap.Internal.Impl.Const.get? m₂ k |
Lean.Doc.Data.instTypeNameTactic | Lean.Elab.DocString.Builtin | TypeName Lean.Doc.Data.Tactic |
LieRinehartAlgebra.Hom.comp._proof_1 | Mathlib.Algebra.LieRinehartAlgebra.Defs | ∀ {R : Type u_3} {A₁ : Type u_7} {L₁ : Type u_2} {A₂ : Type u_5} {L₂ : Type u_4} {A₃ : Type u_6} {L₃ : Type u_1}
[inst : CommRing R] [inst_1 : CommRing A₁] [inst_2 : LieRing L₁] [inst_3 : Module A₁ L₁]
[inst_4 : LieRingModule L₁ A₁] [inst_5 : CommRing A₂] [inst_6 : LieRing L₂] [inst_7 : Module A₂ L₂]
[inst_8 : LieRingModule L₂ A₂] [inst_9 : CommRing A₃] [inst_10 : LieRing L₃] [inst_11 : Module A₃ L₃]
[inst_12 : LieRingModule L₃ A₃] [inst_13 : Algebra R A₁] [inst_14 : LieAlgebra R L₁] [inst_15 : Algebra R A₂]
[inst_16 : LieAlgebra R L₂] [inst_17 : Algebra R A₃] [inst_18 : LieAlgebra R L₃] {σ₁₂ : A₁ →ₐ[R] A₂}
{σ₂₃ : A₂ →ₐ[R] A₃} (f : LieRinehartAlgebra.Hom σ₁₂ L₁ L₂) (g : LieRinehartAlgebra.Hom σ₂₃ L₂ L₃) (x : A₁) (x_1 : L₁),
(g.comp f.toLieHom) (x • x_1) = (σ₂₃.comp σ₁₂) x • (g.comp f.toLieHom) x_1 |
multipliable_of_exists_eq_zero | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoidWithZero α] [inst_1 : TopologicalSpace α] {f : β → α}
{L : SummationFilter β}, (∃ b, f b = 0) → ∀ [L.LeAtTop], Multipliable f L |
_private.Init.Data.String.Lemmas.FindPos.0.String.Slice.posGE_le_iff._simp_1_3 | Init.Data.String.Lemmas.FindPos | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) |
CharTwo.add_cancel_right | Mathlib.Algebra.CharP.Two | ∀ {R : Type u_1} [inst : Semiring R] [CharP R 2] (a b : R), a + b + b = a |
Mathlib.Tactic.Contrapose.contrapose.negate_iff | Mathlib.Tactic.Contrapose | Lean.Option Bool |
_private.Mathlib.GroupTheory.Coxeter.Basic.0.CoxeterSystem.getElem_alternatingWord._proof_1_5 | Mathlib.GroupTheory.Coxeter.Basic | ∀ {B : Type u_1} (i j : B) (n k : ℕ), k ≤ n → ¬k = 0 → k - 1 < (CoxeterSystem.alternatingWord i j n).length |
convex_halfSpace_le | Mathlib.Analysis.Convex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_4} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E] [inst_4 : AddCommMonoid β] [inst_5 : PartialOrder β] [IsOrderedAddMonoid β]
[inst_7 : Module 𝕜 β] [PosSMulMono 𝕜 β] {f : E → β}, IsLinearMap 𝕜 f → ∀ (r : β), Convex 𝕜 {w | f w ≤ r} |
Sym2.sortEquiv_apply_coe | Mathlib.Data.Sym.Sym2.Order | ∀ {α : Type u_1} [inst : LinearOrder α] (s : Sym2 α), ↑(Sym2.sortEquiv s) = (s.inf, s.sup) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.