name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Limits.prod.symmetry' | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P Q : C) [inst_1 : CategoryTheory.Limits.HasBinaryProduct P Q]
[inst_2 : CategoryTheory.Limits.HasBinaryProduct Q P],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.fst)
... | null | true |
Matrix.empty_vecAlt1 | Mathlib.Data.Fin.VecNotation | ∀ (α : Type u_1) {h : 0 = 0 + 0}, Matrix.vecAlt1 h ![] = ![] | null | true |
_private.Std.Sat.AIG.RefVecOperator.Fold.0.Std.Sat.AIG.RefVec.denote_fold_and._proof_1_1 | Std.Sat.AIG.RefVecOperator.Fold | ∀ {len : ℕ}, ¬0 ≤ len → False | null | false |
_private.Mathlib.Data.List.Interleave.0.List.interleaves_ofFn_odd._proof_1_24 | Mathlib.Data.List.Interleave | ∀ {n : ℕ} (i : Fin n), 2 * ↑i + 2 ≤ 2 * n → ¬(2 * ↑i + 2) % 2 = 0 → (2 * ↑i + 2) / 2 < n | null | false |
CategoryTheory.NatTrans.leftOp._proof_1 | Mathlib.CategoryTheory.Opposites | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {F G : CategoryTheory.Functor C Dᵒᵖ} (α : F ⟶ G) (X Y : Cᵒᵖ)
(f : X ⟶ Y),
(CategoryTheory.CategoryStruct.comp (G.leftOp.map f) (α.app (Opposite.unop Y)).unop).op =
(CategoryTheory.Cate... | null | false |
IsUnit.isUnit_iff_mulLeft_bijective | Mathlib.Algebra.Group.Units.Basic | ∀ {M : Type u_1} [inst : Monoid M] {a : M}, IsUnit a ↔ Function.Bijective fun x => a * x | null | true |
UniformSpace.Completion.ring._proof_30 | Mathlib.Topology.Algebra.UniformRing | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : UniformSpace α] [IsTopologicalRing α] [inst_3 : IsUniformAddGroup α]
(a b c : UniformSpace.Completion α), a * (b + c) = a * b + a * c | null | false |
TopologicalSpace.Opens.comap._proof_4 | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} {β : Type u_1} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : C(α, β))
(x x_1 : TopologicalSpace.Opens β),
{ carrier := ⇑f ⁻¹' ↑(x ⊓ x_1), is_open' := ⋯ } = { carrier := ⇑f ⁻¹' ↑(x ⊓ x_1), is_open' := ⋯ } | null | false |
Matrix.normedSpace | Mathlib.Analysis.Matrix.Normed | {R : Type u_1} →
{m : Type u_3} →
{n : Type u_4} →
{α : Type u_5} →
[inst : Fintype m] →
[inst_1 : Fintype n] →
[inst_2 : NormedField R] →
[inst_3 : SeminormedAddCommGroup α] → [NormedSpace R α] → NormedSpace R (Matrix m n α) | Normed space instance (using sup norm of sup norm) for matrices over a normed space. Not
declared as an instance because there are several natural choices for defining the norm of a
matrix. | true |
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 | null | true |
BoundedContinuousFunction.instFunLike | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] → [inst_1 : PseudoMetricSpace β] → FunLike (BoundedContinuousFunction α β) α β | null | true |
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... | null | true |
unitInterval.sigmoid._proof_1 | Mathlib.Analysis.SpecialFunctions.Sigmoid | ∀ (x : ℝ), 0 ≤ x.sigmoid ∧ x.sigmoid ≤ 1 | null | false |
NormedSpace.restrictScalars._proof_1 | Mathlib.Analysis.Normed.Module.Basic | ∀ (𝕜 : Type u_2) (𝕜' : Type u_1) (E : Type u_3) [inst : NormedField 𝕜] [inst_1 : NormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] [inst_3 : SeminormedAddCommGroup E] (c : 𝕜) (x : E),
‖(algebraMap 𝕜 𝕜') c‖ * ‖x‖ = ‖c‖ * ‖x‖ | null | false |
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... | null | true |
Lean.Core.instMonadLogCoreM | Lean.CoreM | Lean.MonadLog Lean.CoreM | null | true |
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} | The transcendence degree of a commutative algebra `A` over a commutative ring `R` is
defined to be the maximal cardinality of an `R`-algebraically independent set in `A`. | true |
Function.Involutive.rightInverse | Mathlib.Logic.Function.Basic | ∀ {α : Sort u} {f : α → α}, Function.Involutive f → Function.RightInverse f f | null | true |
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 | null | false |
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₂) | null | false |
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.GradedOb... | null | true |
Lean.Grind.NatModule.one_nsmul | Init.Grind.Module.Basic | ∀ {M : Type u} [inst : Lean.Grind.NatModule M] (a : M), 1 • a = a | null | true |
Module.Basis.constr_def | Mathlib.LinearAlgebra.Basis.Defs | ∀ {M' : Type u_5} [inst : AddCommMonoid M'] {ι : Type u_7} {R : Type u_8} {M : Type u_9} [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_10)
[inst_5 : Semiring S] [inst_6 : Module S M'] [inst_7 : SMulCommClass R S M'] (f : ι → M'),
... | null | true |
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 | null | true |
_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 | null | 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) | null | false |
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
(Cat... | null | false |
Lean.Meta.Grind.Split.instInhabitedState | Lean.Meta.Tactic.Grind.Types | Inhabited Lean.Meta.Grind.Split.State | null | true |
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 ... | null | true |
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 =... | Given `f : NormedAddGroupHom G H` for some complete `G`, if every element `x` of the image of
an isometric immersion `j : NormedAddGroupHom K H` has a preimage under `f` whose norm is at most
`C*‖x‖` then the same holds for elements of the (topological) closure of this image with constant
`C+ε` instead of `C`, for any ... | true |
Int.closedBall_eq_Icc | Mathlib.Topology.Instances.Int | ∀ (x : ℤ) (r : ℝ), Metric.closedBall x r = Set.Icc ⌈↑x - r⌉ ⌊↑x + r⌋ | null | true |
BitVec.getLsbD_ofNatLT | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} (x : ℕ) (lt : x < 2 ^ n) (i : ℕ), (x#'lt).getLsbD i = x.testBit i | null | true |
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 ⋯ | `Fin.take` intertwines with `List.take` via `List.get`. | true |
Filter.frequently_true_iff_neBot._simp_1 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} (f : Filter α), (∃ᶠ (x : α) in f, True) = f.NeBot | null | false |
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 := ⋯ } | null | true |
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 | The right unitor: `X ⊗ 𝟙_ C ≃ X` | true |
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... | null | false |
CategoryTheory.AddMon.forget_δ | Mathlib.CategoryTheory.Monoidal.Mon | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X Y : CategoryTheory.AddMon C),
CategoryTheory.Functor.OplaxMonoidal.δ (CategoryTheory.AddMon.forget C) X Y =
CategoryTheory.CategoryStruct.id (CategoryTheory.Mon... | null | true |
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 | null | true |
Mathlib.Tactic.BicategoryLike.Mor₂Iso.isStructural._unsafe_rec | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | Mathlib.Tactic.BicategoryLike.Mor₂Iso → Bool | null | false |
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) | null | true |
_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 | null | 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) | null | false |
Fin.lt_sub_iff | Mathlib.Algebra.Group.Fin.Basic | ∀ {n : ℕ} {a b : Fin n}, a < a - b ↔ a < b | null | true |
Function.Injective | Init.Data.Function | {α : Sort u_1} → {β : Sort u_2} → (α → β) → Prop | A function `f : α → β` is called injective if `f x = f y` implies `x = y`. | true |
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 | null | true |
CategoryTheory.ObjectProperty.preservesLimit_iff | Mathlib.CategoryTheory.ObjectProperty.FunctorCategory.PreservesLimits | ∀ {J : Type u_1} {C : Type u_2} (K : Type u_3) [inst : CategoryTheory.Category.{v_1, u_3} K]
[inst_1 : CategoryTheory.Category.{v_3, u_1} J] [inst_2 : CategoryTheory.Category.{v_4, u_2} C]
(F : CategoryTheory.Functor K J) (G : CategoryTheory.Functor J C),
CategoryTheory.ObjectProperty.preservesLimit F G ↔ Categor... | null | true |
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... | If a functor `F` is zero, then any cone for `F` with a zero point is limit. | true |
_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 «$α»)) →
Option Q(PartialOrder «$α») →
(e : Q(«$α»)) →
(p : Q(PartialOrder «$α»)) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness z e (some p)) →
Lean.MetaM (Mathlib.Meta.P... | null | false |
String.Slice.Pos.prevAux._proof_6 | Init.Data.String.Basic | ∀ {s : String.Slice} (off : ℕ), off + 1 < s.utf8ByteSize → off < s.utf8ByteSize | null | false |
_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 (α ... | null | false |
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.Lis... | null | true |
_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.Sh... | null | false |
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 } | null | false |
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) | null | true |
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) | null | false |
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₁.p... | For fans on maps `f₁ : ι₁ → C`, `f₂ : ι₂ → C` and a binary fan on their
cone points, construct one family of morphisms indexed by `ι₁ ⊕ ι₂` | true |
Submodule.isTopCompl_bot_top | Mathlib.Topology.Algebra.Module.Complement | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : TopologicalSpace M] [inst_2 : AddCommGroup M]
[inst_3 : Module R M], Submodule.IsTopCompl ⊥ ⊤ | null | true |
IncidenceAlgebra.instNonAssocSemiring | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | {𝕜 : Type u_1} →
{α : Type u_4} →
[inst : Preorder α] →
[LocallyFiniteOrder α] → [DecidableEq α] → [inst_3 : NonAssocSemiring 𝕜] → NonAssocSemiring (IncidenceAlgebra 𝕜 α) | null | true |
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 | null | true |
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 | **Alias** of the reverse direction of `Finset.prod_ne_zero_iff`. | true |
_private.Mathlib.Combinatorics.Graph.Delete.0.Graph.deleteEdges_isLoopAt._simp_1_1 | Mathlib.Combinatorics.Graph.Delete | ∀ {α : Type u_1} {β : Type u_2} (G : Graph α β) (F : Set β), G.deleteEdges F = G.restrict (G.edgeSet \ F) | null | false |
Aesop.Iteration | Aesop.Tree.Data | Type | null | true |
_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) | null | false |
NFA.eval | Mathlib.Computability.NFA | {α : Type u} → {σ : Type v} → NFA α σ → List α → Set σ | `M.eval x` computes all possible paths though `M` with input `x` starting at an element of
`M.start`. | true |
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 := ⋯ } | null | true |
_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) | null | false |
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 | null | false |
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 ⋯ | null | true |
_private.Mathlib.Algebra.Homology.ExactSequence.0.CategoryTheory.ComposableArrows.isComplex₂_iff._proof_3 | Mathlib.Algebra.Homology.ExactSequence | ¬1 ≤ 2 → False | null | 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 | Generate `CodeBlock` for `doReassignArrow; doElems`
`doReassignArrow` is of the form
```
(doIdDecl <|> doPatDecl)
```
| true |
_private.Batteries.Recycling.RBTree.WF.0.RBTree.RBNode.balLeft.match_4.congr_eq_1._sparseCasesOn_2 | Batteries.Recycling.RBTree.WF | {α : Type u} →
{motive : RBTree.RBNode α → Sort u_1} →
(t : RBTree.RBNode α) →
((c : RBTree.RBColor) →
(l : RBTree.RBNode α) → (v : α) → (r : RBTree.RBNode α) → motive (RBTree.RBNode.node c l v r)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
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 { len := 1 }) ⟶ Y) →
autoParam (CategoryTheory.CategoryStruct.comp SSet.ι₀ h = ... | null | true |
String.apply_skipSuffixWhile_bool_eq_false._proof_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {p : Char → Bool} {s : String} {h : s.skipSuffixWhile p ≠ s.startPos}, (s.skipSuffixWhile p).prev h ≠ s.endPos | null | false |
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 η) | null | true |
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 | null | true |
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 (CategoryTheor... | null | true |
_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 | null | 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 | null | true |
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 | null | true |
div_eq_inv_self | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] {a b : G}, a / b = b⁻¹ ↔ a = 1 | null | true |
Finset.min_mem_image_coe | Mathlib.Data.Finset.Max | ∀ {α : Type u_1} [inst : LinearOrder α] {s : Finset α}, s.Nonempty → s.min ∈ Finset.image WithTop.some s | null | true |
_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 | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0.Int8.reduceBin._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.2990342300._hygCtx._hyg.9 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | Lean.Name → ℕ → (Int8 → Int8 → Int8) → Lean.Expr → Lean.Meta.SimpM Lean.Meta.Simp.DStep | null | false |
Rep.coindFunctor_map | Mathlib.RepresentationTheory.Coinduced | ∀ (k : Type u) {G : Type v} {H : Type w} [inst : CommRing k] [inst_1 : Monoid G] [inst_2 : Monoid H] (φ : G →* H)
{X Y : Rep.{t, u, v} k G} (f : X ⟶ Y), (Rep.coindFunctor k φ).map f = Rep.coindMap φ f | null | true |
ImportGraph.Shake.NeedsKind.andThen_assoc | ImportGraph.Shake.Basic | ∀ (k₁ k₂ k₃ : ImportGraph.Shake.NeedsKind) (connectable₁₂ : k₁.target = k₂.source)
(connectable₂₃ : k₂.target = k₃.source), (k₁.andThen k₂ ⋯).andThen k₃ ⋯ = k₁.andThen (k₂.andThen k₃ ⋯) ⋯ | null | true |
_private.Mathlib.Tactic.Translate.Expr.0.Mathlib.Tactic.Translate.applyReplacementFun.visitApp.match_5 | Mathlib.Tactic.Translate.Expr | (motive : Lean.Name → Sort u_1) →
(n₀ : Lean.Name) → (Unit → motive `OfNat) → (Unit → motive `OfNat.ofNat) → ((x : Lean.Name) → motive x) → motive n₀ | null | false |
_private.Mathlib.Analysis.Polynomial.MahlerMeasure.0.Polynomial.mahlerMeasure_le_sqrt_sum_sq_norm_coeff._simp_1_4 | Mathlib.Analysis.Polynomial.MahlerMeasure | ∀ {p : Prop} [Decidable p], (¬¬p) = p | null | false |
_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 | null | false |
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)) | An extension of an `R`-algebra `S` is an `R` algebra `P` together with a surjection `P →ₐ[R] S`.
Also see `Algebra.Extension.ofSurjective`.
| true |
isOfFinAddOrder_ofMul_iff | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : Monoid G] {x : G}, IsOfFinAddOrder (Additive.ofMul x) ↔ IsOfFinOrder x | null | true |
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 | null | true |
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 | null | true |
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]
[... | null | false |
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 (Sigm... | null | true |
CategoryTheory.Functor.instPreservesLimitsOfShapeOppositeFullSubcategoryTypeHasWeightedLimitWeightedLimFlipObj'OfHasColimitsOfShapeOfHasWeightedLimFlipObj | Mathlib.CategoryTheory.Limits.Weighted.PreservesLimit | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {C : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} C]
{K : Type u_1} [inst_2 : CategoryTheory.Category.{v_1, u_1} K] [CategoryTheory.Limits.HasColimitsOfShape Kᵒᵖ (Type w)]
(F : CategoryTheory.Functor J C) [F.HasWeightedLimFlipObj],
CategoryTheory.Lim... | null | true |
Matrix.cRank_one | Mathlib.LinearAlgebra.Matrix.Rank | ∀ {m : Type um} {R : Type uR} [inst : Semiring R] [inst_1 : DecidableEq m] [StrongRankCondition R],
Matrix.cRank 1 = Cardinal.lift.{uR, um} (Cardinal.mk m) | null | true |
NonUnitalRing.sub._inherited_default | Mathlib.Algebra.Ring.Defs | {α : Type u_1} →
(zero : α) →
(add : α → α → α) →
(∀ (a b c : α), a + b + c = a + (b + c)) →
(∀ (a : α), 0 + a = a) →
(∀ (a : α), a + 0 = a) →
(nsmul : ℕ → α → α) →
(∀ (x : α), 0 • x = 0) → (∀ (n : ℕ) (x : α), (n + 1) • x = n • x + x) → (α → α) → α → α → α | null | false |
_private.Lean.DocString.Markdown.0.Lean.Doc.midLineSpecial.match_1 | Lean.DocString.Markdown | (motive : Char → Sort u_1) → (c : Char) → (Unit → motive '!') → ((x : Char) → motive x) → motive c | null | false |
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 →... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.