name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
le_imp_le_of_le_of_le | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : Preorder α] {a b c d : α}, c ≤ a → b ≤ d → a ≤ b → c ≤ d |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.getStackEntries.isIgnoredArg | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | Lean.Expr → Lean.Expr → Lean.BinderInfo → Lean.MetaM Bool |
CategoryTheory.Limits.HasPushout | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → {X Y Z : C} → (X ⟶ Y) → (X ⟶ Z) → Prop |
Algebra.TensorProduct.algebraMap_def | Mathlib.RingTheory.TensorProduct.Basic | ∀ {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : CommSemiring S] [inst_6 : Algebra S A]
[inst_7 : SMulCommClass R S A],
algebraMap S (TensorProduct R A B) = Algebra.TensorProduct.includeLeftRingHom.comp (algebraMap S A) |
CategoryTheory.Pretopology.gi | Mathlib.CategoryTheory.Sites.Pretopology | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasPullbacks C] →
GaloisInsertion CategoryTheory.Pretopology.toGrothendieck CategoryTheory.GrothendieckTopology.toPretopology |
Lean.RBTree.contains | Lean.Data.RBTree | {α : Type u} → {cmp : α → α → Ordering} → Lean.RBTree α cmp → α → Bool |
CategoryTheory.Limits.instHasCokernelFromSubtype | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {K : Type}
[inst_2 : Finite K] [inst_3 : CategoryTheory.Limits.HasFiniteBiproducts C] (f : K → C) (p : K → Prop),
CategoryTheory.Limits.HasCokernel (CategoryTheory.Limits.biproduct.fromSubtype f p) |
Equiv.ofRightInverseOfCardLE_apply | Mathlib.Data.Fintype.EquivFin | ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β] (hαβ : Fintype.card α ≤ Fintype.card β)
(f : α → β) (g : β → α) (h : Function.RightInverse g f) (a : α), (Equiv.ofRightInverseOfCardLE hαβ f g h) a = f a |
NonUnitalSubalgebra.instModule._proof_1 | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A],
IsScalarTower R R A |
List.countP_cons_of_neg | Init.Data.List.Count | ∀ {α : Type u_1} {p : α → Bool} {a : α} {l : List α}, ¬p a = true → List.countP p (a :: l) = List.countP p l |
ContinuousLinearMap.coe_smul._simp_1 | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {M₁ : Type u_4}
[inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_4 : TopologicalSpace M₂]
[inst_5 : AddCommMonoid M₂] [inst_6 : Module R₁ M₁] [inst_7 : Module R₂ M₂] {S₂ : Type u_9}
[inst_8 : DistribSMul S₂ M₂] [inst_9 : SMulCommClass R₂ S₂ M₂] [inst_10 : ContinuousConstSMul S₂ M₂] (c : S₂)
(f : M₁ →SL[σ₁₂] M₂), c • ↑f = ↑(c • f) |
_private.Mathlib.Topology.UniformSpace.Cauchy.0.isComplete_iff_ultrafilter'._simp_1_1 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} {s : Set α} {f : Filter α}, (f ≤ Filter.principal s) = (s ∈ f) |
Std.TreeMap.maxKey_le_maxKey_insert | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α} {v : β}
{he : t.isEmpty = false}, (cmp (t.maxKey he) ((t.insert k v).maxKey ⋯)).isLE = true |
Aesop.RuleBuilderOptions.mk | Aesop.Builder.Basic | Option (Array Lean.Name) →
Option Aesop.IndexingMode →
Option (Array Aesop.CasesPattern) →
Option Lean.Term →
Option Lean.Meta.TransparencyMode → Option Lean.Meta.TransparencyMode → Aesop.RuleBuilderOptions |
MeasureTheory.setLIntegral_congr_fun | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → ENNReal} {s : Set α},
MeasurableSet s → Set.EqOn f g s → ∫⁻ (x : α) in s, f x ∂μ = ∫⁻ (x : α) in s, g x ∂μ |
_private.Lean.Meta.Tactic.Simp.SimpTheorems.0.Lean.Meta.preprocess | Lean.Meta.Tactic.Simp.SimpTheorems | Lean.Expr → Lean.Expr → Bool → Bool → Lean.MetaM (List (Lean.Expr × Lean.Expr)) |
OrderedFinpartition.compAlongOrderedFinpartitionL_apply | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type u_4}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : ℕ} (c : OrderedFinpartition n)
(f : ContinuousMultilinearMap 𝕜 (fun i => F) G) (p : (i : Fin c.length) → ContinuousMultilinearMap 𝕜 (fun i => E) F),
((OrderedFinpartition.compAlongOrderedFinpartitionL 𝕜 E F G c) f) p = c.compAlongOrderedFinpartition f p |
BoundedContinuousFunction.instAddZeroClass | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
{R : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : PseudoMetricSpace R] →
[inst_2 : AddZeroClass R] → [BoundedAdd R] → [ContinuousAdd R] → AddZeroClass (BoundedContinuousFunction α R) |
isLocalMax_of_deriv | Mathlib.Analysis.Calculus.DerivativeTest | ∀ {f : ℝ → ℝ} {b : ℝ},
ContinuousAt f b →
(∀ᶠ (x : ℝ) in nhdsWithin b {b}ᶜ, DifferentiableAt ℝ f x) →
(∀ᶠ (x : ℝ) in nhdsWithin b (Set.Iio b), 0 ≤ deriv f x) →
(∀ᶠ (x : ℝ) in nhdsWithin b (Set.Ioi b), deriv f x ≤ 0) → IsLocalMax f b |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basic.0.RootPairing.GeckConstruction.ωConj._simp_4 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basic | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c |
LinearEquiv.finTwoArrow_apply | Mathlib.LinearAlgebra.Pi | ∀ (R : Type u) (M : Type v) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
⇑(LinearEquiv.finTwoArrow R M) = fun f => (f 0, f 1) |
NNRat.cast_lt_natCast._simp_1 | Mathlib.Data.Rat.Cast.Order | ∀ {K : Type u_5} [inst : Semifield K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] {m : ℚ≥0} {n : ℕ},
(↑m < ↑n) = (m < ↑n) |
MulChar.ofUnitHom.eq_1 | Mathlib.NumberTheory.MulChar.Basic | ∀ {R : Type u_1} [inst : CommMonoid R] {R' : Type u_2} [inst_1 : CommMonoidWithZero R'] (f : Rˣ →* R'ˣ),
MulChar.ofUnitHom f =
{ toFun := fun x => if hx : IsUnit x then ↑(f hx.unit) else 0, map_one' := ⋯, map_mul' := ⋯, map_nonunit' := ⋯ } |
CStarMatrix.map_map | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_5} {B : Type u_6} {C : Type u_7} {M : Matrix m n A} {f : A → B} {g : B → C},
(M.map f).map g = M.map (g ∘ f) |
AddLocalization.le._proof_1 | Mathlib.GroupTheory.MonoidLocalization.Order | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [IsOrderedCancelAddMonoid α] {s : AddSubmonoid α}
{a₁ b₁ : α} {a₂ b₂ : ↥s} {c₁ d₁ : α} {c₂ d₂ : ↥s},
(AddLocalization.r s) (a₁, a₂) (b₁, b₂) →
(AddLocalization.r s) (c₁, c₂) (d₁, d₂) → (↑c₂ + a₁ ≤ ↑a₂ + c₁) = (↑d₂ + b₁ ≤ ↑b₂ + d₁) |
_private.Mathlib.Tactic.Simproc.Factors.0.Nat.primeFactorsList_ofNat.match_3 | Mathlib.Tactic.Simproc.Factors | (motive :
(u : Lean.Level) →
(α : Q(Sort u)) →
(e : Q(«$α»)) →
Lean.Meta.SimpM (Lean.Meta.Simp.StepQ e) → Lean.Meta.SimpM (Lean.Meta.Simp.StepQ e) → Sort u_1) →
(u : Lean.Level) →
(α : Q(Sort u)) →
(e : Q(«$α»)) →
(__alt __alt_1 : Lean.Meta.SimpM (Lean.Meta.Simp.StepQ e)) →
((α : Q(Type)) →
(e : Q(«$α»)) →
(__alt __alt_2 : Lean.Meta.SimpM (Lean.Meta.Simp.StepQ e)) →
motive Lean.Level.zero.succ α e __alt __alt_2) →
((x : Lean.Level) →
(α : Q(Sort x)) →
(e : Q(«$α»)) →
(__alt __alt_2 : Lean.Meta.SimpM (Lean.Meta.Simp.StepQ e)) → motive x α e __alt __alt_2) →
motive u α e __alt __alt_1 |
Std.ExtTreeMap.contains_eq_isSome_getElem? | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {a : α},
t.contains a = t[a]?.isSome |
OrderAddMonoidHom.comp | Mathlib.Algebra.Order.Hom.Monoid | {α : Type u_2} →
{β : Type u_3} →
{γ : Type u_4} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
[inst_2 : Preorder γ] →
[inst_3 : AddZeroClass α] →
[inst_4 : AddZeroClass β] → [inst_5 : AddZeroClass γ] → (β →+o γ) → (α →+o β) → α →+o γ |
Int8.toInt_ofNat' | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, (Int8.ofNat n).toInt = (↑n).bmod Int8.size |
Unitization.instCommCStarAlgebra._proof_12 | Mathlib.Analysis.CStarAlgebra.Unitization | ∀ {A : Type u_1} [inst : NonUnitalCommCStarAlgebra A], CStarRing (Unitization ℂ A) |
AugmentedSimplexCategory.equivAugmentedCosimplicialObject_functor_map_left | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C]
{X Y : CategoryTheory.Functor (CategoryTheory.WithInitial SimplexCategory) C} (η : X ⟶ Y),
(AugmentedSimplexCategory.equivAugmentedCosimplicialObject.functor.map η).left = η.app CategoryTheory.WithInitial.star |
OrderHom.coe_antisymmetrization | Mathlib.Order.Antisymmetrization | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (f : α →o β),
⇑f.antisymmetrization = Quotient.map' ⇑f ⋯ |
Lean.ModuleSetup.mk.sizeOf_spec | Lean.Setup | ∀ (name : Lean.Name) (package? : Option Lean.PkgId) (isModule : Bool) (imports? : Option (Array Lean.Import))
(importArts : Lean.NameMap Lean.ImportArtifacts) (dynlibs plugins : Array System.FilePath)
(options : Lean.LeanOptions),
sizeOf
{ name := name, package? := package?, isModule := isModule, imports? := imports?, importArts := importArts,
dynlibs := dynlibs, plugins := plugins, options := options } =
1 + sizeOf name + sizeOf package? + sizeOf isModule + sizeOf imports? + sizeOf importArts + sizeOf dynlibs +
sizeOf plugins +
sizeOf options |
isCancelMul_iff | Mathlib.Algebra.Group.Defs | ∀ (G : Type u) [inst : Mul G], IsCancelMul G ↔ IsLeftCancelMul G ∧ IsRightCancelMul G |
_private.Mathlib.RingTheory.Kaehler.Basic.0.KaehlerDifferential.kerTotal_mkQ_single_mul._simp_1_1 | Mathlib.RingTheory.Kaehler.Basic | ∀ {α : Type u_1} {M : Type u_5} {R : Type u_11} [inst : Zero M] [inst_1 : SMulZeroClass R M] (c : R) (a : α) (b : M),
(fun₀ | a => c • b) = c • fun₀ | a => b |
_private.Mathlib.GroupTheory.CoprodI.0.Monoid.CoprodI.Word.mem_rcons_iff._proof_1_13 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] [inst_1 : (i : ι) → DecidableEq (M i)] {i j : ι}
(p : Monoid.CoprodI.Word.Pair M i) (m : M j),
⟨j, m⟩ ∈
(if h : p.head = 1 then p.tail
else { toList := ⟨i, p.head⟩ :: p.tail.toList, ne_one := ⋯, chain_ne := ⋯ }).toList ↔
⟨j, m⟩ ∈ p.tail.toList ∨ ¬m = 1 ∧ ∃ (h : i = j), m = h ▸ p.head |
CategoryTheory.ShortComplex.SnakeInput.functorP_obj | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C), CategoryTheory.ShortComplex.SnakeInput.functorP.obj S = S.P |
HNNExtension.NormalWord.noConfusion | Mathlib.GroupTheory.HNNExtension | {P : Sort u} →
{G : Type u_1} →
{inst : Group G} →
{A B : Subgroup G} →
{d : HNNExtension.NormalWord.TransversalPair G A B} →
{t : HNNExtension.NormalWord d} →
{G' : Type u_1} →
{inst' : Group G'} →
{A' B' : Subgroup G'} →
{d' : HNNExtension.NormalWord.TransversalPair G' A' B'} →
{t' : HNNExtension.NormalWord d'} →
G = G' →
inst ≍ inst' →
A ≍ A' → B ≍ B' → d ≍ d' → t ≍ t' → HNNExtension.NormalWord.noConfusionType P t t' |
CategoryTheory.Limits.BinaryBicone.instIsSplitEpiSnd | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{P Q : C} (c : CategoryTheory.Limits.BinaryBicone P Q), CategoryTheory.IsSplitEpi c.snd |
CategoryTheory.Functor.CorepresentableBy.isoCoreprX | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{F : CategoryTheory.Functor C (Type v)} →
[hF : F.IsCorepresentable] → {Y : C} → F.CorepresentableBy Y → (Y ≅ F.coreprX) |
Matrix.toLinOfInv._proof_1 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_3} [inst : CommSemiring R] {m : Type u_4} {n : Type u_5} [inst_1 : Fintype n] [inst_2 : DecidableEq n]
{M₁ : Type u_1} {M₂ : Type u_2} [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂] [inst_5 : Module R M₁]
[inst_6 : Module R M₂] (v₁ : Module.Basis n R M₁) (v₂ : Module.Basis m R M₂) [inst_7 : Fintype m]
[inst_8 : DecidableEq m] {M : Matrix m n R} {M' : Matrix n m R},
M' * M = 1 → ∀ (x : M₁), ((Matrix.toLin v₂ v₁) M') (((Matrix.toLin v₁ v₂) M) x) = x |
Lean.Doc.Data.Option.noConfusionType | Lean.Elab.DocString.Builtin | Sort u → Lean.Doc.Data.Option → Lean.Doc.Data.Option → Sort u |
Lean.Expr.ReplaceLevelImpl.State._sizeOf_inst | Lean.Util.ReplaceLevel | SizeOf Lean.Expr.ReplaceLevelImpl.State |
List.Sublist.findIdx?_isSome | Init.Data.List.Find | ∀ {α : Type u_1} {p : α → Bool} {l₁ l₂ : List α},
l₁.Sublist l₂ → (List.findIdx? p l₁).isSome = true → (List.findIdx? p l₂).isSome = true |
_private.Mathlib.Data.Finset.Dedup.0.Multiset.toFinset_subset._simp_1_1 | Mathlib.Data.Finset.Dedup | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ |
Matrix.uniqueAlgEquiv | Mathlib.LinearAlgebra.Matrix.Unique | {m : Type u_1} →
{A : Type u_3} →
{R : Type u_4} →
[inst : Unique m] →
[inst_1 : Semiring A] → [inst_2 : CommSemiring R] → [inst_3 : Algebra R A] → Matrix m m A ≃ₐ[R] A |
Lean.Parser.Tactic.revert | Init.Tactics | Lean.ParserDescr |
_private.Mathlib.Analysis.SpecialFunctions.BinaryEntropy.0.Real.strictConcaveOn_qaryEntropy._simp_1_1 | Mathlib.Analysis.SpecialFunctions.BinaryEntropy | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Ioo a b) = (a < x ∧ x < b) |
SetLike.GradeZero.coe_intCast | Mathlib.Algebra.DirectSum.Internal | ∀ {ι : Type u_1} {σ : Type u_2} {R : Type u_4} [inst : Ring R] [inst_1 : AddMonoid ι] [inst_2 : SetLike σ R]
[inst_3 : AddSubgroupClass σ R] (A : ι → σ) [inst_4 : SetLike.GradedMonoid A] (z : ℤ), ↑↑z = ↑z |
CategoryTheory.Adjunction.homEquiv | Mathlib.CategoryTheory.Adjunction.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D C} → (F ⊣ G) → (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G.obj Y) |
Filter.Realizer.ctorIdx | Mathlib.Data.Analysis.Filter | {α : Type u_1} → {f : Filter α} → f.Realizer → ℕ |
Lean.Doc.Part.brecOn_1 | Lean.DocString.Types | {i : Type u} →
{b : Type v} →
{p : Type w} →
{motive_1 : Lean.Doc.Part i b p → Sort u_1} →
{motive_2 : Array (Lean.Doc.Part i b p) → Sort u_1} →
{motive_3 : List (Lean.Doc.Part i b p) → Sort u_1} →
(t : Array (Lean.Doc.Part i b p)) →
((t : Lean.Doc.Part i b p) → t.below → motive_1 t) →
((t : Array (Lean.Doc.Part i b p)) → Lean.Doc.Part.below_1 t → motive_2 t) →
((t : List (Lean.Doc.Part i b p)) → Lean.Doc.Part.below_2 t → motive_3 t) → motive_2 t |
Representation.FiniteCyclicGroup.coinvariantsEquiv | Mathlib.RepresentationTheory.Homological.FiniteCyclic | {k : Type u_1} →
{G : Type u_2} →
[inst : CommRing k] →
[inst_1 : Group G] →
{V : Type u_4} →
[inst_2 : AddCommGroup V] →
[inst_3 : Module k V] →
(ρ : Representation k G V) →
(g : G) →
[Fintype G] →
(∀ (x : G), x ∈ Subgroup.zpowers g) → ρ.Coinvariants ≃ₗ[k] V ⧸ (ρ g - LinearMap.id).range |
String.validFor_mkIterator | Batteries.Data.String.Lemmas | ∀ (s : String), String.Legacy.Iterator.ValidFor [] s.toList (String.Legacy.mkIterator s) |
AlgebraicGeometry.Scheme.instOverSpecResidueField | Mathlib.AlgebraicGeometry.ResidueField | {X : AlgebraicGeometry.Scheme} → (x : ↥X) → (AlgebraicGeometry.Spec (X.residueField x)).Over X |
HomologicalComplex.restriction.sc'Iso_hom_τ₃ | Mathlib.Algebra.Homology.Embedding.RestrictionHomology | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : HomologicalComplex C c') (e : c.Embedding c') [inst_2 : e.IsRelIff] (i j k : ι) {i' j' k' : ι'}
(hi' : e.f i = i') (hj' : e.f j = j') (hk' : e.f k = k') (hi'' : c'.prev j' = i') (hk'' : c'.next j' = k'),
(HomologicalComplex.restriction.sc'Iso K e i j k hi' hj' hk' hi'' hk'').hom.τ₃ = (K.restrictionXIso e hk').hom |
List.set_eq_modify | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (a : α) (n : ℕ) (l : List α), l.set n a = l.modify n fun x => a |
CongruenceSubgroup.Gamma1_mem._simp_1 | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | ∀ (N : ℕ) (A : Matrix.SpecialLinearGroup (Fin 2) ℤ),
(A ∈ CongruenceSubgroup.Gamma1 N) = (↑(↑A 0 0) = 1 ∧ ↑(↑A 1 1) = 1 ∧ ↑(↑A 1 0) = 0) |
isAddRegular_toColex | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : AddMonoid α] {a : α}, IsAddRegular (toColex a) ↔ IsAddRegular a |
_private.Mathlib.CategoryTheory.Comma.Over.Basic.0.CategoryTheory.Over.isRightAdjoint_post.match_1 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} T] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {G : CategoryTheory.Functor D T} (motive : G.IsRightAdjoint → Prop)
(x : G.IsRightAdjoint), (∀ (F : CategoryTheory.Functor T D) (a : F ⊣ G), motive ⋯) → motive x |
MeasureTheory.JordanDecomposition.casesOn | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | {α : Type u_2} →
[inst : MeasurableSpace α] →
{motive : MeasureTheory.JordanDecomposition α → Sort u} →
(t : MeasureTheory.JordanDecomposition α) →
((posPart negPart : MeasureTheory.Measure α) →
[posPart_finite : MeasureTheory.IsFiniteMeasure posPart] →
[negPart_finite : MeasureTheory.IsFiniteMeasure negPart] →
(mutuallySingular : posPart.MutuallySingular negPart) →
motive
{ posPart := posPart, negPart := negPart, posPart_finite := posPart_finite,
negPart_finite := negPart_finite, mutuallySingular := mutuallySingular }) →
motive t |
RingEquiv.nonUnitalSubsemiringCongr._proof_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] {s t : NonUnitalSubsemiring R}, s = t → ↑s = ↑t |
PerfectionMap.lift._proof_4 | Mathlib.RingTheory.Perfection | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] (R : Type u_1) [inst_1 : CommSemiring R] [inst_2 : CharP R p]
[inst_3 : PerfectRing R p] (S : Type u_2) [inst_4 : CommSemiring S] [inst_5 : CharP S p] (P : Type u_3)
[inst_6 : CommSemiring P] [inst_7 : CharP P p] [inst_8 : PerfectRing P p] (π : P →+* S) (m : PerfectionMap p π)
(f : R →+* S), (fun f => π.comp f) ((fun f => (↑m.equiv.symm).comp ((Perfection.lift p R S) f)) f) = f |
AlgebraicGeometry.LocallyRingedSpace.restrict_presheaf_map | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | ∀ {U : TopCat} (X : AlgebraicGeometry.LocallyRingedSpace) {f : U ⟶ X.toTopCat}
(h : Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom f)) {X_1 Y : (TopologicalSpace.Opens ↑U)ᵒᵖ}
(f_1 : X_1 ⟶ Y), (X.restrict h).presheaf.map f_1 = X.presheaf.map (h.functor.map f_1.unop).op |
FiberBundleCore.Index | Mathlib.Topology.FiberBundle.Basic | {ι : Type u_1} →
{B : Type u_2} →
{F : Type u_3} → [inst : TopologicalSpace B] → [inst_1 : TopologicalSpace F] → FiberBundleCore ι B F → Type u_1 |
Lean.Meta.Grind.instInhabitedTheorems.default | Lean.Meta.Tactic.Grind.Theorems | {a : Type} → Lean.Meta.Grind.Theorems a |
CategoryTheory.ShortComplex.ShortExact.singleδ.eq_1 | Mathlib.Algebra.Homology.DerivedCategory.SingleTriangle | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : HasDerivedCategory C] {S : CategoryTheory.ShortComplex C} (hS : S.ShortExact),
hS.singleδ =
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.SingleFunctors.evaluation C (DerivedCategory C) 0).mapIso
(DerivedCategory.singleFunctorsPostcompQIso C)).hom.app
S.X₃)
(CategoryTheory.CategoryStruct.comp (DerivedCategory.triangleOfSESδ ⋯)
((CategoryTheory.shiftFunctor (DerivedCategory C) 1).map
(((CategoryTheory.SingleFunctors.evaluation C (DerivedCategory C) 0).mapIso
(DerivedCategory.singleFunctorsPostcompQIso C)).inv.app
S.X₁))) |
BooleanSubalgebra.instCompleteLattice._proof_4 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_1} [inst : BooleanAlgebra α] (_L _M : BooleanSubalgebra α) (_a : α), _a ∈ ↑_L ∧ _a ∈ ↑_M → _a ∈ ↑_M |
_private.Mathlib.Topology.ShrinkingLemma.0.ShrinkingLemma.PartialRefinement.chainSup._simp_8 | Mathlib.Topology.ShrinkingLemma | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i |
Quiver.symmetrifyStar | Mathlib.Combinatorics.Quiver.Covering | {U : Type u_1} →
[inst : Quiver U] → (u : U) → Quiver.Star (Quiver.Symmetrify.of.obj u) ≃ Quiver.Star u ⊕ Quiver.Costar u |
_private.Mathlib.RingTheory.Unramified.LocalStructure.0.Algebra.IsUnramifiedAt.exists_hasStandardEtaleSurjectionOn_of_exists_adjoin_singleton_eq_top._simp_1_17 | Mathlib.RingTheory.Unramified.LocalStructure | ∀ {α : Type u_1} [inst : NonUnitalRing α] {a b c : α}, a ∣ c → (a ∣ b + c) = (a ∣ b) |
Lean.Compiler.LCNF.eqvTypes | Lean.Compiler.LCNF.InferType | Lean.Expr → Lean.Expr → Bool |
eventuallyMeasurableSpace._proof_1 | Mathlib.MeasureTheory.MeasurableSpace.EventuallyMeasurable | ∀ {α : Type u_1} (m : MeasurableSpace α) (l : Filter α), ∃ t, MeasurableSet t ∧ ∅ =ᶠ[l] t |
Lean.Elab.Tactic.RCases.RCasesPatt.one | Lean.Elab.Tactic.RCases | Lean.Syntax → Lean.Name → Lean.Elab.Tactic.RCases.RCasesPatt |
AlgebraicGeometry.Scheme.mem_zeroLocus_iff._simp_1 | Mathlib.AlgebraicGeometry.Scheme | ∀ (X : AlgebraicGeometry.Scheme) {U : X.Opens} (s : Set ↑(X.presheaf.obj (Opposite.op U))) (x : ↥X),
(x ∈ X.zeroLocus s) = ∀ f ∈ s, x ∉ X.basicOpen f |
Mathlib.Tactic.Coherence.LiftHom.noConfusion | Mathlib.Tactic.CategoryTheory.Coherence | {P : Sort u_1} →
{C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{X Y : C} →
{inst_1 : Mathlib.Tactic.Coherence.LiftObj X} →
{inst_2 : Mathlib.Tactic.Coherence.LiftObj Y} →
{f : X ⟶ Y} →
{t : Mathlib.Tactic.Coherence.LiftHom f} →
{C' : Type u} →
{inst' : CategoryTheory.Category.{v, u} C'} →
{X' Y' : C'} →
{inst'_1 : Mathlib.Tactic.Coherence.LiftObj X'} →
{inst'_2 : Mathlib.Tactic.Coherence.LiftObj Y'} →
{f' : X' ⟶ Y'} →
{t' : Mathlib.Tactic.Coherence.LiftHom f'} →
C = C' →
inst ≍ inst' →
X ≍ X' →
Y ≍ Y' →
inst_1 ≍ inst'_1 →
inst_2 ≍ inst'_2 →
f ≍ f' → t ≍ t' → Mathlib.Tactic.Coherence.LiftHom.noConfusionType P t t' |
Lean.Meta.ZetaUnusedMode.ctorElim | Lean.Meta.HaveTelescope | {motive : Lean.Meta.ZetaUnusedMode → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Meta.ZetaUnusedMode) → ctorIdx = t.ctorIdx → Lean.Meta.ZetaUnusedMode.ctorElimType ctorIdx → motive t |
Mathlib.Tactic.DepRewrite.Conv.depRw | Mathlib.Tactic.DepRewrite | Lean.ParserDescr |
_private.Mathlib.Combinatorics.Additive.FreimanHom.0.Fin.isAddFreimanIso_Iio._simp_1_1 | Mathlib.Combinatorics.Additive.FreimanHom | ∀ (n : ℕ) [inst : NeZero n], 0 = ⊥ |
MulArchimedeanOrder.le_def | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : Group M] [inst_1 : Lattice M] {a b : MulArchimedeanOrder M},
a ≤ b ↔ ∃ n, |MulArchimedeanOrder.val b|ₘ ≤ |MulArchimedeanOrder.val a|ₘ ^ n |
ContinuousLinearMap.reApplyInnerSelf_continuous | Mathlib.Analysis.InnerProductSpace.LinearMap | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(T : E →L[𝕜] E), Continuous T.reApplyInnerSelf |
_private.Mathlib.NumberTheory.Chebyshev.0.Chebyshev.primeCounting_eq_theta_div_log_add_integral._simp_1_7 | Mathlib.NumberTheory.Chebyshev | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False |
CategoryTheory.WithInitial.of.injEq | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} (a a_1 : C), (CategoryTheory.WithInitial.of a = CategoryTheory.WithInitial.of a_1) = (a = a_1) |
conditionallyCompleteLatticeOfLatticeOfsSup | Mathlib.Order.ConditionallyCompleteLattice.Defs | (α : Type u_5) →
[H1 : Lattice α] →
[inst : SupSet α] → (∀ (s : Set α), BddAbove s → s.Nonempty → IsLUB s (sSup s)) → ConditionallyCompleteLattice α |
Lean.Linter.UnusedVariables.References.casesOn | Lean.Linter.UnusedVariables | {motive : Lean.Linter.UnusedVariables.References → Sort u} →
(t : Lean.Linter.UnusedVariables.References) →
((constDecls : Std.HashSet Lean.Syntax.Range) →
(fvarDefs : Std.HashMap Lean.Syntax.Range Lean.Linter.UnusedVariables.FVarDefinition) →
(fvarUses : Std.HashSet Lean.FVarId) →
(fvarAliases : Std.HashMap Lean.FVarId Lean.FVarId) →
(assignments : Array (Lean.PersistentHashMap Lean.MVarId Lean.Expr)) →
motive
{ constDecls := constDecls, fvarDefs := fvarDefs, fvarUses := fvarUses, fvarAliases := fvarAliases,
assignments := assignments }) →
motive t |
CategoryTheory.PreZeroHypercover.Hom.mk.injEq | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreZeroHypercover S}
{F : CategoryTheory.PreZeroHypercover S} (s₀ : E.I₀ → F.I₀) (h₀ : (i : E.I₀) → E.X i ⟶ F.X (s₀ i))
(w₀ :
autoParam (∀ (i : E.I₀), CategoryTheory.CategoryStruct.comp (h₀ i) (F.f (s₀ i)) = E.f i)
CategoryTheory.PreZeroHypercover.Hom.w₀._autoParam)
(s₀_1 : E.I₀ → F.I₀) (h₀_1 : (i : E.I₀) → E.X i ⟶ F.X (s₀_1 i))
(w₀_1 :
autoParam (∀ (i : E.I₀), CategoryTheory.CategoryStruct.comp (h₀_1 i) (F.f (s₀_1 i)) = E.f i)
CategoryTheory.PreZeroHypercover.Hom.w₀._autoParam),
({ s₀ := s₀, h₀ := h₀, w₀ := w₀ } = { s₀ := s₀_1, h₀ := h₀_1, w₀ := w₀_1 }) = (s₀ = s₀_1 ∧ h₀ ≍ h₀_1) |
Equiv.Set.sumDiffSubset_apply_inl | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_3} {s t : Set α} (h : s ⊆ t) [inst : DecidablePred fun x => x ∈ s] (x : ↑s),
(Equiv.Set.sumDiffSubset h) (Sum.inl x) = Set.inclusion h x |
_private.Mathlib.Algebra.Regular.Defs.0.isRegular_iff.match_1_3 | Mathlib.Algebra.Regular.Defs | ∀ {R : Type u_1} [inst : Mul R] {c : R} (motive : IsLeftRegular c ∧ IsRightRegular c → Prop)
(x : IsLeftRegular c ∧ IsRightRegular c), (∀ (h1 : IsLeftRegular c) (h2 : IsRightRegular c), motive ⋯) → motive x |
Option.forIn'_join._proof_1 | Init.Data.Option.Monadic | ∀ {α : Type u_1} (o : Option (Option α)), ∀ o' ∈ o, ∀ a ∈ o', a ∈ o.join |
_private.Lean.Meta.Tactic.Grind.EMatch.0.Lean.Meta.Grind.EMatch.checkDefEq.match_1 | Lean.Meta.Tactic.Grind.EMatch | (motive : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr → Sort u_1) →
(__discr : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) →
((fst : Array Lean.Expr) → (fst_1 : Array Lean.BinderInfo) → (rhsExpr : Lean.Expr) → motive (fst, fst_1, rhsExpr)) →
motive __discr |
_private.Lean.OriginalConstKind.0.Lean.wasOriginallyTheorem.match_1 | Lean.OriginalConstKind | (motive : Lean.ConstantKind → Sort u_1) →
(x : Lean.ConstantKind) → (Unit → motive Lean.ConstantKind.thm) → ((x : Lean.ConstantKind) → motive x) → motive x |
CategoryTheory.ShortComplex.rightHomologyIso_hom_comp_homologyι_assoc | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasHomology] {Z : C} (h : S.opcycles ⟶ Z),
CategoryTheory.CategoryStruct.comp S.rightHomologyIso.hom (CategoryTheory.CategoryStruct.comp S.homologyι h) =
CategoryTheory.CategoryStruct.comp S.rightHomologyι h |
MeasurableEquiv.curry_apply | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ (ι : Type u_6) (κ : Type u_7) (X : Type u_8) [inst : MeasurableSpace X] (a : ι × κ → X) (a_1 : ι) (a_2 : κ),
(MeasurableEquiv.curry ι κ X) a a_1 a_2 = a (a_1, a_2) |
Prod.instCompleteAtomicBooleanAlgebra._proof_9 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteAtomicBooleanAlgebra α] [inst_1 : CompleteAtomicBooleanAlgebra β]
(x : α × β), x ⊓ xᶜ ≤ ⊥ |
Std.ExtDHashMap.getKey?_modify | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {k k' : α}
{f : β k → β k}, (m.modify k f).getKey? k' = if (k == k') = true then if k ∈ m then some k else none else m.getKey? k' |
Lean.Lsp.LeanIdentifier.mk._flat_ctor | Lean.Data.Lsp.Internal | Lean.Name → Lean.Name → Bool → Lean.Lsp.LeanIdentifier |
ZMod.ringEquivCongr._proof_1 | Mathlib.Data.ZMod.Basic | ∀ (m n : ℕ) (h : m + 1 = n + 1) (a b : ZMod (m + 1)),
(finCongr h).toFun (a * b) = (finCongr h).toFun a * (finCongr h).toFun b |
isotypicComponents | Mathlib.RingTheory.SimpleModule.Isotypic | (R : Type u_2) →
(M : Type u) → [inst : Ring R] → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → Set (Submodule R M) |
Bundle.Trivialization.liftCM.eq_1 | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (T : Bundle.Trivialization F proj),
T.liftCM = { toFun := fun ex => ⟨T.lift ↑ex.1 ↑ex.2, ⋯⟩, continuous_toFun := ⋯ } |
System.Uri.UriEscape.letterF | Init.System.Uri | UInt8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.