name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getD_inter_of_contains_eq_false_right._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) | null | false |
_private.Mathlib.SetTheory.Cardinal.Order.0.Cardinal.le_mk_iff_exists_set.match_1_1 | Mathlib.SetTheory.Cardinal.Order | ∀ {α : Type u_1} (x : Type u_1) (motive : Cardinal.mk x ≤ Cardinal.mk α → Prop) (x_1 : Cardinal.mk x ≤ Cardinal.mk α),
(∀ (f : x → α) (hf : Function.Injective f), motive ⋯) → motive x_1 | null | false |
instFintypeWithBot._proof_3 | Mathlib.Data.Fintype.WithTopBot | ∀ {α : Type u_1} [inst : Fintype α] (x : WithBot α), x ∈ instFintypeWithBot._aux_1 | null | false |
Std.ExtHashMap.isSome_getKey?_iff_mem._simp_1 | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {a : α}, ((m.getKey? a).isSome = true) = (a ∈ m) | null | false |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM1to0.tr.match_1.eq_2 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} (M : Λ → Turing.TM1.Stmt Γ Λ σ)
(motive : Turing.TM1to0.Λ' M → Γ → Sort u_4) (q : Turing.TM1.Stmt Γ Λ σ) (v : σ) (s : Γ)
(h_1 : (snd : σ) → (x : Γ) → motive (none, snd) x)
(h_2 : (q : Turing.TM1.Stmt Γ Λ σ) → (v : σ) → (s : Γ) → motive (some q, v) s),
(match (some ... | null | true |
Matrix.replicateRow_empty | Mathlib.LinearAlgebra.Matrix.Notation | ∀ {α : Type u} {ι : Type u_1}, Matrix.replicateRow ι ![] = Matrix.of fun x => ![] | null | true |
PresheafOfModules.limitPresheafOfModules._proof_5 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Limits | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {J : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} J] (F : CategoryTheory.Functor J (PresheafOfModules R))
[inst_2 :
∀ (X : Cᵒᵖ),
Small.{u_1, max u_6 u_1}
↑((F.comp (PresheafOfModules.e... | null | false |
Lean.Doc.Parser.OrderedListType.numDot.elim | Lean.DocString.Parser | {motive : Lean.Doc.Parser.OrderedListType → Sort u} →
(t : Lean.Doc.Parser.OrderedListType) → t.ctorIdx = 0 → motive Lean.Doc.Parser.OrderedListType.numDot → motive t | null | false |
Lean.Meta.Simp.Arith.Nat.instReprExprCnstr_lean.repr | Lean.Meta.Tactic.Simp.Arith.Nat.Basic | Nat.Internal.Linear.ExprCnstr → ℕ → Std.Format | null | true |
ContinuousLinearEquiv.trans_apply | Mathlib.Topology.Algebra.Module.Equiv.Basic | ∀ {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 : RingHomInvPair σ₂₃ σ₃₂] [inst_6 : RingHomInvPair ... | null | true |
_private.Mathlib.GroupTheory.GroupAction.Blocks.0.MulAction.IsBlock.of_subset._simp_1_2 | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : MulAction α β] {A : Set β} {a : α} {x : β},
(x ∈ a • A) = (a⁻¹ • x ∈ A) | null | false |
AlgEquiv | Mathlib.Algebra.Algebra.Equiv | (R : Type u) →
(A : Type v) →
(B : Type w) →
[inst : CommSemiring R] →
[inst_1 : Semiring A] → [inst_2 : Semiring B] → [Algebra R A] → [Algebra R B] → Type (max v w) | An equivalence of algebras (denoted as `A ≃ₐ[R] B`)
is an equivalence of rings commuting with the actions of scalars. | true |
NonUnitalAlgHom.ext | Mathlib.Algebra.Algebra.NonUnitalHom | ∀ {R : Type u} {S : Type u₁} [inst : Monoid R] [inst_1 : Monoid S] {φ : R →* S} {A : Type v} {B : Type w}
[inst_2 : NonUnitalNonAssocSemiring A] [inst_3 : DistribMulAction R A] [inst_4 : NonUnitalNonAssocSemiring B]
[inst_5 : DistribMulAction S B] {f g : A →ₛₙₐ[φ] B}, (∀ (x : A), f x = g x) → f = g | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Copy.0.SimpleGraph.copyCount_bot._simp_1_3 | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {α : Type u_1} {s : Finset α} {a : α}, (s = {a}) = (a ∈ s ∧ ∀ x ∈ s, x = a) | null | false |
Array.foldr_append | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β → β} {b : β} {xs ys : Array α},
Array.foldr f b (xs ++ ys) = Array.foldr f (Array.foldr f b ys) xs | null | true |
Std.PRange.InfinitelyUpwardEnumerable.mk._flat_ctor | Init.Data.Range.Polymorphic.UpwardEnumerable | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α],
(∀ (a : α), (Std.PRange.succ? a).isSome = true) → Std.PRange.InfinitelyUpwardEnumerable α | null | false |
Std.DTreeMap.Internal.Impl.IteratedNewInsertionInto | Std.Data.DTreeMap.Internal.Operations | {α : Type u} → {β : α → Type v} → [Ord α] → Std.DTreeMap.Internal.Impl α β → Type (max 0 u v) | A tree map obtained by inserting elements into `t` if they are new, bundled with an inductive principle. | true |
KummerDedekind.quotMapEquivQuotQuotMap._proof_5 | Mathlib.NumberTheory.KummerDedekind | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {x : S} {I : Ideal R},
(Ideal.span {Polynomial.map (Ideal.Quotient.mk I) (minpoly R x)}).IsTwoSided | null | false |
List.merge_of_le._f | Init.Data.List.Sort.Lemmas | ∀ {α : Type u_1} {le : α → α → Bool} (x : List α)
(f :
List.below (motive := fun x =>
∀ (x_1 : List α), (∀ (a b : α), a ∈ x → b ∈ x_1 → le a b = true) → x.merge x_1 le = x ++ x_1) x)
(x_1 : List α), (∀ (a b : α), a ∈ x → b ∈ x_1 → le a b = true) → x.merge x_1 le = x ++ x_1 | null | false |
Std.DTreeMap.Internal.RooSliceData.range | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} → {β : α → Type v} → [inst : Ord α] → Std.DTreeMap.Internal.RooSliceData α β → Std.Roo α | null | true |
CategoryTheory.Limits.prod | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryProducts | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → (X Y : C) → [CategoryTheory.Limits.HasBinaryProduct X Y] → C | If we have a product of `X` and `Y`, we can access it using `prod X Y` or `X ⨯ Y`. | true |
Fintype.sumRight | Mathlib.Data.Fintype.Card | {α : Type u_3} → {β : Type u_4} → [Fintype (α ⊕ β)] → Fintype β | Given that `α ⊕ β` is a fintype, `β` is also a fintype. This is non-computable as it uses
that `Sum.inr` is an injection, but there's no clear inverse if `β` is empty. | true |
Lean.Parser.Command.universe.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer | null | true |
Finset.Nat.antidiagonal_filter_fst_le_of_le | Mathlib.Data.Finset.NatAntidiagonal | ∀ {n k : ℕ},
k ≤ n →
{a ∈ Finset.HasAntidiagonal.antidiagonal n | a.1 ≤ k} =
Finset.map ((Function.Embedding.refl ℕ).prodMap { toFun := fun x => x + (n - k), inj' := ⋯ })
(Finset.HasAntidiagonal.antidiagonal k) | null | true |
MonoidAlgebra.mapAddEquiv_trans | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {S : Type u_4} {T : Type u_5} {M : Type u_6} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : Semiring T] [inst_3 : Mul M] (e₁ : R ≃+ S) (e₂ : S ≃+ T),
MonoidAlgebra.mapAddEquiv M (e₁.trans e₂) = (MonoidAlgebra.mapAddEquiv M e₁).trans (MonoidAlgebra.mapAddEquiv M e₂) | null | true |
Set.preimage_const_sub_uIcc | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] (a b c : α),
(fun x => a - x) ⁻¹' Set.uIcc b c = Set.uIcc (a - b) (a - c) | null | true |
_private.Mathlib.RingTheory.Trace.Quotient.0._aux_Mathlib_RingTheory_Trace_Quotient___unexpand_IsLocalRing_maximalIdeal_1 | Mathlib.RingTheory.Trace.Quotient | Lean.PrettyPrinter.Unexpander | null | false |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate.0.PSigma.casesOn._arg_pusher | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → ... | null | false |
_private.Mathlib.GroupTheory.GroupAction.Blocks.0.MulAction.BlockMem.instBoundedOrder._simp_1 | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {α : Type u} (s : Set α), (s ⊆ Set.univ) = True | null | false |
InnerProductSpace.Core.inner_zero_right | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[c : PreInnerProductSpace.Core 𝕜 F] (x : F), inner 𝕜 x 0 = 0 | null | true |
CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_zero_unitIso_inv_app | Mathlib.CategoryTheory.Triangulated.Opposite.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ] (X : Cᵒᵖ),
(CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C 0).unitIso.inv.app X =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.shiftFunctor C 0).map ((CategoryTheory.shiftFunctorZero Cᵒᵖ ... | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Reflexive.0._auto_147 | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | Lean.Syntax | null | false |
WithBot.decidableLT | Mathlib.Order.WithBot | {α : Type u_1} → [inst : LT α] → [DecidableLT α] → DecidableLT (WithBot α) | null | true |
Multiset.noncommProd | Mathlib.Data.Finset.NoncommProd | {α : Type u_3} → [inst : Monoid α] → (s : Multiset α) → {x | x ∈ s}.Pairwise Commute → α | Product of a `s : Multiset α` with `[Monoid α]`, given a proof that `*` commutes
on all elements `x ∈ s`. | true |
CategoryTheory.Abelian.SpectralObject.coreE₂CohomologicalFin._proof_19 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (l : ℕ) (r : ℤ) (pq pq' : ℤ × Fin l),
(ComplexShape.spectralSequenceFin l (r, 1 - r)).Rel pq pq' →
autoParam (2 ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_20 →
pq.2.castSucc = Fin.clamp (↑↑pq'.2 + (r - 1)).toNat l | null | false |
CategoryTheory.InjectiveResolution.Hom.recOn | Mathlib.CategoryTheory.Preadditive.Injective.Resolution | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
{Z : C} →
{I : CategoryTheory.InjectiveResolution Z} →
{Z' : C} →
{I' : CategoryTheory.InjectiveReso... | null | false |
Lean.Parser.TokenCacheEntry.noConfusionType | Lean.Parser.Types | Sort u → Lean.Parser.TokenCacheEntry → Lean.Parser.TokenCacheEntry → Sort u | null | false |
OrderMonoidHom.inlₗ._proof_3 | Mathlib.Algebra.Order.Monoid.Lex | ∀ (α : Type u_1) (β : Type u_2) [inst : Monoid α] [inst_1 : PartialOrder α] [inst_2 : Monoid β] [inst_3 : Preorder β],
(Prod.Lex.toLexOrderHom.comp ↑(OrderMonoidHom.inl α β)).toFun 1 =
(Prod.Lex.toLexOrderHom.comp ↑(OrderMonoidHom.inl α β)).toFun 1 | null | false |
Representation.IntertwiningMap.lTensor_comp_rTensor | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} {U : Type u_5} [inst : CommSemiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : AddCommMonoid U] [inst_5 : Module A V]
[inst_6 : Module A W] [inst_7 : Module A U] {ρ : Representation A G V} {σ : Representation A... | null | true |
MeasureTheory.VectorMeasure.Integrable.map | Mathlib.MeasureTheory.VectorMeasure.Integral | ∀ {X : Type u_2} {E : Type u_4} {F : Type u_5} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup F] {μ : MeasureTheory.VectorMeasure X F} {β : Type u_9} [inst_2 : MeasurableSpace β]
{φ : X → β} {f : β → E},
MeasureTheory.AEStronglyMeasurable f (MeasureTheory.Measure.map φ μ.varia... | null | true |
Action.instPreservesColimitForgetOfHasColimitComp | Mathlib.CategoryTheory.Action.Limits | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {G : Type u_2} [inst_1 : Monoid G] {J : Type u_3}
[inst_2 : CategoryTheory.Category.{v_2, u_3} J] (K : CategoryTheory.Functor J (Action V G))
[CategoryTheory.Limits.HasColimit (K.comp (Action.forget V G))],
CategoryTheory.Limits.PreservesColimit K (Ac... | `Action.forget V G : Action V G ⥤ V` preserves the colimit of some `K : J ⥤ Action V G` if
`K ⋙ Action.forget V G` has a colimit. | true |
CompleteLat.dualEquiv | Mathlib.Order.Category.CompleteLat | CompleteLat ≌ CompleteLat | The equivalence between `CompleteLat` and itself induced by `OrderDual` both ways. | true |
FirstOrder.Language.Term.subst.eq_2 | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {α : Type u'} {β : Type v'} (x : α → L.Term β) (l : ℕ) (f : L.Functions l)
(ts : Fin l → L.Term α), (FirstOrder.Language.func f ts).subst x = FirstOrder.Language.func f fun i => (ts i).subst x | null | true |
Std.Tactic.BVDecide.BVExpr.decEq._proof_4 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ (lw ln rw rn : ℕ), ln = rn ∧ lw = rw → lw = rw | null | false |
Lean.Compiler.LCNF.UnreachableBranches.Value.bot.sizeOf_spec | Lean.Compiler.LCNF.ElimDeadBranches | sizeOf Lean.Compiler.LCNF.UnreachableBranches.Value.bot = 1 | null | true |
_private.Mathlib.RingTheory.PicardGroup.0.Module.Invertible.finite_projective.match_1_3 | Mathlib.RingTheory.PicardGroup | ∀ (R : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(S : Finset (M × Module.Dual R M)) (f : (↥S →₀ Module.Dual R M) →ₗ[R] R),
let N := Module.Dual R M;
∀ (motive : (∃ h, f ∘ₗ h = LinearMap.id) → Prop) (x : ∃ h, f ∘ₗ h = LinearMap.id),
(∀ (g : R →ₗ[R] ↥S →₀ ... | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex.0.SSet.stdSimplex.bijective_image_objEquiv_toOrderHom_univ._simp_1_3 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {F : Sort u_1} {α : Sort u_2} {β : Sort u_3} [inst : FunLike F α β] [i : EmbeddingLike F α β] (f : F) {x y : α},
(f x = f y) = (x = y) | null | false |
CategoryTheory.OverPresheafAux.counitForward_naturality₁ | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)}
{F G : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} (η : F ⟶ G)
(s : (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ) (x : F.obj s),
CategoryTheory.OverP... | null | true |
Order.coheight_bot_eq_krullDim | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : OrderBot α], ↑(Order.coheight ⊥) = Order.krullDim α | null | true |
Frm.hasForgetToLat._proof_2 | Mathlib.Order.Category.Frm | ∀ {X Y Z : Frm} (f : X ⟶ Y) (g : Y ⟶ Z),
Lat.ofHom { toFun := ⇑(Frm.Hom.hom (CategoryTheory.CategoryStruct.comp f g)), map_sup' := ⋯, map_inf' := ⋯ } =
CategoryTheory.CategoryStruct.comp (Lat.ofHom { toFun := ⇑(Frm.Hom.hom f), map_sup' := ⋯, map_inf' := ⋯ })
(Lat.ofHom { toFun := ⇑(Frm.Hom.hom g), map_sup' ... | null | false |
Multiset.count_bind | Mathlib.Data.Multiset.Bind | ∀ {α : Type u_1} {β : Type v} [inst : DecidableEq α] {m : Multiset β} {f : β → Multiset α} {a : α},
Multiset.count a (m.bind f) = (Multiset.map (fun b => Multiset.count a (f b)) m).sum | null | true |
PointedCone.mem_hull_singleton | Mathlib.Geometry.Convex.Cone.Pointed | ∀ {R : Type u_1} {E : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommMonoid E] [inst_4 : Module R E] {x y : E}, y ∈ R ∙₊ x ↔ ∃ r, 0 ≤ r ∧ r • x = y | null | true |
groupCohomology.H1Iso | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | {k G : Type u} →
[inst : CommRing k] →
[inst_1 : Group G] →
(A : Rep.{u, u, u} k G) → groupCohomology.H1 A ≅ (groupCohomology.shortComplexH1 A).moduleCatLeftHomologyData.H | The 1st group cohomology of `A`, defined as the 1st cohomology of the complex of inhomogeneous
cochains, is isomorphic to `cocycles₁ A ⧸ coboundaries₁ A`, which is a simpler type. | true |
LinearPMap.graph | Mathlib.LinearAlgebra.LinearPMap | {R : Type u_1} →
[inst : Ring R] →
{E : Type u_4} →
[inst_1 : AddCommGroup E] →
[inst_2 : Module R E] →
{F : Type u_5} → [inst_3 : AddCommGroup F] → [inst_4 : Module R F] → (E →ₗ.[R] F) → Submodule R (E × F) | The graph of a `LinearPMap` viewed as a submodule on `E × F`. | true |
Ordinal.type_Iio_lt | Mathlib.SetTheory.Ordinal.Basic | ∀ {α : Type u} [inst : LinearOrder α] [inst_1 : WellFoundedLT α] (x : α),
Ordinal.type LT.lt = (Ordinal.typein LT.lt).toRelEmbedding x | null | true |
Monoid.PushoutI.homEquiv._proof_8 | Mathlib.GroupTheory.PushoutI | ∀ {ι : Type u_1} {G : ι → Type u_2} {H : Type u_3} {K : Type u_4} [inst : Monoid K] [inst_1 : (i : ι) → Monoid (G i)]
[inst_2 : Monoid H] {φ : (i : ι) → H →* G i} (fst : (i : ι) → G i →* K) (snd : H →* K)
(property : ∀ (i : ι), ((fst, snd).1 i).comp (φ i) = (fst, snd).2),
(fun f => ⟨(fun i => f.comp (Monoid.Pusho... | null | false |
Equiv.trans_cancel_left | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {β : Sort v} {γ : Sort w} (e : α ≃ β) (f : β ≃ γ) (g : α ≃ γ), e.trans f = g ↔ f = e.symm.trans g | null | true |
Wbtw.angle₂₃₁_eq_zero_of_ne | Mathlib.Geometry.Euclidean.Angle.Unoriented.Affine | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {p₁ p₂ p₃ : P}, Wbtw ℝ p₁ p₂ p₃ → p₂ ≠ p₃ → EuclideanGeometry.angle p₂ p₃ p₁ = 0 | If the second of three points is weakly between the other two, and not equal to the third,
the angle at the third point is zero. | true |
_private.Mathlib.GroupTheory.Perm.Support.0.Equiv.Perm.support_swap_mul_swap._simp_1_1 | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} {a : α}, (a ∈ []) = False | null | false |
CochainComplex.HomComplex.Cochain.shift_v' | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} {n : ℤ} (γ : CochainComplex.HomComplex.Cochain K L n) (a p q : ℤ) (hpq : p + n = q),
(γ.shift a).v p q hpq = γ.v (p + a) (q + a) ⋯ | null | true |
Finsupp.LinearEquiv.finsuppUnique._proof_2 | Mathlib.LinearAlgebra.Finsupp.Pi | ∀ (M : Type u_2) [inst : AddCommMonoid M] (α : Type u_1) [inst_1 : Unique α] (x x_1 : α →₀ M),
(Finsupp.equivFunOnFinite.trans (Equiv.funUnique α M)).toFun (x + x_1) =
(Finsupp.equivFunOnFinite.trans (Equiv.funUnique α M)).toFun (x + x_1) | null | false |
_private.Mathlib.Topology.Semicontinuity.Basic.0.upperSemicontinuousAt_inv_iff._simp_1_1 | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : Preorder β] {f : α → β} {x : α},
LowerSemicontinuousAt f x = LowerSemicontinuousWithinAt f Set.univ x | null | false |
Std.TreeSet.max?_eq_some_maxD | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp],
t.isEmpty = false → ∀ {fallback : α}, t.max? = some (t.maxD fallback) | null | true |
HasFDerivAt.of_local_left_inverse | Mathlib.Analysis.Calculus.FDeriv.OfCompLeft | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {g : E → F} {f : F → E}
{f' : F ≃L[𝕜] E} {a : E},
ContinuousAt g a → HasFDerivAt f (↑f') (g a) → (∀ᶠ (y : E) ... | If `f (g x) = x` for `x` in some neighborhood of `a`, `g` is continuous at `a`,
and `f` has an invertible derivative `f'` at `g a`, then `g` has the derivative `f'⁻¹` at `a`.
This is one of the easy parts of the inverse function theorem: it assumes that we already have
an inverse function. | true |
List.Nodup.getEquiv._proof_1 | Mathlib.Data.List.NodupEquivFin | ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α),
l.Nodup → ∀ (i : Fin l.length), (fun x => ⟨List.idxOf (↑x) l, ⋯⟩) ((fun i => ⟨l.get i, ⋯⟩) i) = i | null | false |
LinearMap.mem_ker._simp_1 | Mathlib.Algebra.Module.Submodule.Ker | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂} {y : M}, (y ∈ f.ker) = (f y = 0) | null | false |
Complex.tan_periodic | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | Function.Periodic Complex.tan ↑Real.pi | null | true |
Mathlib.Tactic.LibraryRewrite.Rewrite.recOn | Mathlib.Tactic.Widget.LibraryRewrite | {motive : Mathlib.Tactic.LibraryRewrite.Rewrite → Sort u} →
(t : Mathlib.Tactic.LibraryRewrite.Rewrite) →
((symm : Bool) →
(proof replacement : Lean.Expr) →
(stringLength : ℕ) →
(extraGoals : Array (Lean.MVarId × Lean.BinderInfo)) →
(makesNewMVars : Bool) →
... | null | false |
_private.Mathlib.Probability.Process.HittingTime.0.MeasureTheory.hittingAfter_bot_le_iff._simp_1_1 | Mathlib.Probability.Process.HittingTime | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β}
{n i : ι} {ω : Ω} [WellFoundedLT ι], (MeasureTheory.hittingAfter u s n ω ≤ ↑i) = ∃ j ∈ Set.Icc n i, u j ω ∈ s | null | false |
IO.userError | Init.System.IOError | String → IO.Error | Constructs an `IO.Error` from a string.
`IO.Error` is the type of exceptions thrown by the `IO` monad.
| true |
HeytingAlgebra.toOrderBot | Mathlib.Order.Heyting.Basic | {α : Type u_4} → [self : HeytingAlgebra α] → OrderBot α | null | true |
CategoryTheory.MonoOver.map.congr_simp | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f f_1 : X ⟶ Y) (e_f : f = f_1)
[inst_1 : CategoryTheory.Mono f], CategoryTheory.MonoOver.map f = CategoryTheory.MonoOver.map f_1 | null | true |
Pell.pos_generator_iff_fundamental | Mathlib.NumberTheory.Pell | ∀ {d : ℤ} (a : Pell.Solution₁ d),
(1 < a.x ∧ 0 < a.y ∧ ∀ (b : Pell.Solution₁ d), ∃ n, b = a ^ n ∨ b = -a ^ n) ↔ Pell.IsFundamental a | A positive solution is a generator (up to sign) of the group of all solutions to the
Pell equation `x^2 - d*y^2 = 1` if and only if it is a fundamental solution. | true |
CochainComplex.Plus.localizerMorphism_functor | Mathlib.Algebra.Homology.DerivedCategory.DerivabilityStructureInjectives | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C],
(CochainComplex.Plus.localizerMorphism C).functor = (CategoryTheory.InjectiveObject.ι C).mapCochainComplexPlus | null | true |
AddGrpCat.uliftFunctor_map | Mathlib.Algebra.Category.Grp.Basic | ∀ {x x_1 : AddGrpCat} (f : x ⟶ x_1),
AddGrpCat.uliftFunctor.map f =
AddGrpCat.ofHom (AddEquiv.ulift.symm.toAddMonoidHom.comp ((AddGrpCat.Hom.hom f).comp AddEquiv.ulift.toAddMonoidHom)) | null | true |
powersHom_apply | Mathlib.Algebra.Group.Nat.Hom | ∀ {M : Type u_1} [inst : Monoid M] (x : M) (n : Multiplicative ℕ), ((powersHom M) x) n = x ^ Multiplicative.toAdd n | null | true |
LocallyConstant.instNonAssocRing._proof_10 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : NonAssocRing Y] (x : ℤ), ⇑↑x = ⇑↑x | null | false |
Std.Roi.Sliceable.noConfusionType | Init.Data.Slice.Notation | Sort u_1 →
{α : Type u} →
{β : Type v} →
{γ : Type w} →
Std.Roi.Sliceable α β γ → {α' : Type u} → {β' : Type v} → {γ' : Type w} → Std.Roi.Sliceable α' β' γ' → Sort u_1 | null | false |
_private.Lean.Parser.Types.0.Lean.Parser.ParserContext.mk.injEq | Lean.Parser.Types | ∀ (toParserContextCore toParserContextCore_1 : Lean.Parser.ParserContextCore),
({ toParserContextCore := toParserContextCore } = { toParserContextCore := toParserContextCore_1 }) =
(toParserContextCore = toParserContextCore_1) | null | true |
Lean.Lsp.DocumentSymbolAux.recOn | Lean.Data.Lsp.LanguageFeatures | {Self : Type} →
{motive : Lean.Lsp.DocumentSymbolAux Self → Sort u} →
(t : Lean.Lsp.DocumentSymbolAux Self) →
((name : String) →
(detail? : Option String) →
(kind : Lean.Lsp.SymbolKind) →
(range selectionRange : Lean.Lsp.Range) →
(children? : Option (Array... | null | false |
_private.Mathlib.LinearAlgebra.Prod.0.LinearMap.ker_coprod_of_disjoint_range._simp_1_3 | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective τ₁₂] {f : M →ₛₗ[τ₁₂] M₂} {x : M₂}, (x ∈ f.range) = ∃ y, f y = x | null | false |
MulEquiv.symm_toContinuousMulEquiv | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {G : Type u} [inst : TopologicalSpace G] {H : Type v} [inst_1 : TopologicalSpace H] [inst_2 : Mul G] [inst_3 : Mul H]
{e : G ≃* H} (he : ∀ (s : Set H), IsOpen (⇑e ⁻¹' s) ↔ IsOpen s),
(e.toContinuousMulEquiv he).symm = e.symm.toContinuousMulEquiv ⋯ | null | true |
MeasureTheory.IsFundamentalDomain.mk'' | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : MeasurableSpace α] {s : Set α}
{μ : MeasureTheory.Measure α},
MeasureTheory.NullMeasurableSet s μ →
(∀ᵐ (x : α) ∂μ, ∃ g, g • x ∈ s) →
(∀ (g : G), g ≠ 1 → MeasureTheory.AEDisjoint μ (g • s) s) →
(∀ (g : G), MeasureT... | For `s` to be a fundamental domain, it's enough to check
`MeasureTheory.AEDisjoint (g • s) s` for `g ≠ 1`. | true |
Lean.Elab.Term.LValResolution.noConfusionType | Lean.Elab.App | Sort u → Lean.Elab.Term.LValResolution → Lean.Elab.Term.LValResolution → Sort u | null | false |
IsPrecomplete.prec | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal R} {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M],
IsPrecomplete I M →
∀ {f : ℕ → M}, (∀ {m n : ℕ}, m ≤ n → f m ≡ f n [SMOD I ^ m • ⊤]) → ∃ L, ∀ (n : ℕ), f n ≡ L [SMOD I ^ n • ⊤] | null | true |
Cardinal.prod_eq_two_power | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {ι : Type u} [Infinite ι] {c : ι → Cardinal.{v}},
(∀ (i : ι), 2 ≤ c i) →
(∀ (i : ι), Cardinal.lift.{u, v} (c i) ≤ Cardinal.lift.{v, u} (Cardinal.mk ι)) →
Cardinal.prod c = 2 ^ Cardinal.lift.{v, u} (Cardinal.mk ι) | null | true |
Lean.Meta.Grind.CongrTheoremCacheKey.mk.noConfusion | Lean.Meta.Tactic.Grind.Types | {P : Sort u} →
{f : Lean.Expr} →
{numArgs : ℕ} →
{f' : Lean.Expr} →
{numArgs' : ℕ} →
{ f := f, numArgs := numArgs } = { f := f', numArgs := numArgs' } → (f = f' → numArgs = numArgs' → P) → P | null | false |
Lean.Meta.Grind.EMatchTheoremConstraint.depthLt.sizeOf_spec | Lean.Meta.Tactic.Grind.Extension | ∀ (lhs n : ℕ), sizeOf (Lean.Meta.Grind.EMatchTheoremConstraint.depthLt lhs n) = 1 + sizeOf lhs + sizeOf n | null | true |
Polynomial.int | Mathlib.Algebra.Ring.Subring.IntPolynomial | {K : Type u_1} → [inst : Field K] → (R : Subring K) → (P : Polynomial K) → (∀ (n : ℕ), P.coeff n ∈ R) → Polynomial ↥R | Given a polynomial in `K[X]` such that all coefficients belong to the subring `R`,
`Polynomial.int` is the corresponding polynomial in `R[X]`. | true |
ContinuousLinearMap.instLoewnerPartialOrder | Mathlib.Analysis.InnerProductSpace.Positive | {𝕜 : Type u_1} →
{E : Type u_2} →
[inst : RCLike 𝕜] → [inst_1 : NormedAddCommGroup E] → [inst_2 : InnerProductSpace 𝕜 E] → PartialOrder (E →L[𝕜] E) | The (Loewner) partial order on continuous linear maps on a Hilbert space determined by
`f ≤ g` if and only if `g - f` is a positive linear map (in the sense of
`ContinuousLinearMap.IsPositive`). With this partial order, the continuous linear maps form a
`StarOrderedRing`. | true |
CochainComplex.triangleOfDegreewiseSplitRotateRotateIso | Mathlib.Algebra.Homology.HomotopyCategory.DegreewiseSplit | {C : Type u_1} →
[inst : CategoryTheory.Category.{v, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
(S : CategoryTheory.ShortComplex (CochainComplex C ℤ)) →
(σ : (n : ℤ) → (S.map (HomologicalComplex.eval C (ComplexShape.up ℤ) n)).Splitting) →
[inst_2 : CategoryTheory.Limits.HasBinaryB... | The canonical isomorphism of triangles
`(triangleOfDegreewiseSplit S σ).rotate.rotate ≅ mappingCone.triangle (homOfDegreewiseSplit S σ)`
when `S` is a degreewise split short exact sequence of cochain complexes. | true |
SubtractionCommMonoid.mk._flat_ctor | Mathlib.Algebra.Group.DivInvMonoid | {G : Type u_2} →
(zero : G) →
(add : G → G → G) →
(∀ (a b c : G), a + b + c = a + (b + c)) →
(∀ (a : G), 0 + a = a) →
(∀ (a : G), a + 0 = a) →
(nsmul : ℕ → G → G) →
autoParam (∀ (x : G), 0 • x = 0) AddMonoid.nsmul_zero._autoParam →
autoParam (∀ (n ... | null | false |
MonoidAlgebra.support_coeff_one | Mathlib.Algebra.MonoidAlgebra.Support | ∀ {k : Type u₁} {G : Type u₂} [inst : Semiring k] [inst_1 : One G] [NeZero 1], (MonoidAlgebra.coeff 1).support = 1 | null | true |
Nat.succ_lt_of_lt_pred | Init.Data.Nat.Basic | ∀ {n : ℕ} {m : ℕ}, n < m.pred → n.succ < m | null | true |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.LiveVars.borrows._default | Lean.Compiler.LCNF.ExplicitRC | Std.HashSet Lean.FVarId | null | false |
CategoryTheory.MonoidalCategory.id_whiskerLeft_symm_assoc | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X X' : C}
(f : X ⟶ X') {Z : C} (h : X' ⟶ Z),
CategoryTheory.CategoryStruct.comp f h =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.leftUnitor X).inv
(CategoryTheory.CategoryS... | null | true |
_private.Std.Data.Internal.List.Associative.0.List.getLast?.match_1.eq_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} (motive : List α → Sort u_2) (a : α) (as : List α) (h_1 : Unit → motive [])
(h_2 : (a : α) → (as : List α) → motive (a :: as)),
(match a :: as with
| [] => h_1 ()
| a :: as => h_2 a as) =
h_2 a as | null | true |
HMod.mk | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → (α → β → γ) → HMod α β γ | null | true |
CategoryTheory.CardinalDirectedPoset.SetCardinalLT.fromSigma._proof_2 | Mathlib.CategoryTheory.Presentable.SharplyLT.Lemmas | ∀ (κ : Cardinal.{u_1}) (X : Type u_1) (x : (κ' : ↑(Set.Iio κ)) × ((↑κ').ord.ToType → X)),
HasCardinalLT (↑x.fst).ord.ToType κ | null | false |
EuclideanDomain.mul_div_assoc | Mathlib.Algebra.EuclideanDomain.Basic | ∀ {R : Type u} [inst : EuclideanDomain R] (x : R) {y z : R}, z ∣ y → x * y / z = x * (y / z) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.