name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.Yoneda.naturality | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C}
(α : CategoryTheory.yoneda.obj X ⟶ CategoryTheory.yoneda.obj Y) {Z Z' : C} (f : Z ⟶ Z') (h : Z' ⟶ X),
CategoryTheory.CategoryStruct.comp f (α.app (Opposite.op Z') h) =
α.app (Opposite.op Z) (CategoryTheory.CategoryStruct.comp f h) |
Finsupp.lt_of_forall_lt_of_lt | Mathlib.Data.Finsupp.Lex | ∀ {α : Type u_1} {N : Type u_2} [inst : Zero N] [inst_1 : LinearOrder α] [inst_2 : PartialOrder N] (a b : Lex (α →₀ N))
(i : α), (∀ j < i, (ofLex a) j = (ofLex b) j) → (ofLex a) i < (ofLex b) i → a < b |
MeasureTheory.SimpleFunc.instSemilatticeSup._proof_3 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : SemilatticeSup β]
(_f _g _h : MeasureTheory.SimpleFunc α β), _f ≤ _h → _g ≤ _h → ∀ (a : α), _f a ⊔ _g a ≤ _h a |
Complex.contDiff_exp | Mathlib.Analysis.SpecialFunctions.ExpDeriv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAlgebra 𝕜 ℂ] {n : WithTop ℕ∞},
ContDiff 𝕜 n Complex.exp |
Frm.Iso.mk._proof_4 | Mathlib.Order.Category.Frm | ∀ {α β : Frm} (e : ↑α ≃o ↑β) (a b : ↑β), e.symm (a ⊓ b) = e.symm a ⊓ e.symm b |
Pi.mulActionWithZero | Mathlib.Algebra.GroupWithZero.Action.Pi | {I : Type u} →
{f : I → Type v} →
(α : Type u_1) →
[inst : MonoidWithZero α] →
[inst_1 : (i : I) → Zero (f i)] → [(i : I) → MulActionWithZero α (f i)] → MulActionWithZero α ((i : I) → f i) |
HomotopicalAlgebra.PathObject.symm_ι | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C}
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] (P : HomotopicalAlgebra.PathObject A), P.symm.ι = P.ι |
SimpleGraph.chromaticNumber_le_card | Mathlib.Combinatorics.SimpleGraph.Coloring | ∀ {V : Type u} {G : SimpleGraph V} [inst : Fintype V], G.chromaticNumber ≤ ↑(Fintype.card V) |
Rat.inv_natCast_num_of_pos | Mathlib.Data.Rat.Lemmas | ∀ {a : ℕ}, 0 < a → (↑a)⁻¹.num = 1 |
Set.sInter_delab | Mathlib.Order.SetNotation | Lean.PrettyPrinter.Delaborator.Delab |
_private.Lean.Meta.InferType.0.Lean.Meta.inferTypeImp.infer.match_1 | Lean.Meta.InferType | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((c : Lean.Name) → motive (Lean.Expr.const c [])) →
((c : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const c us)) →
((n : Lean.Name) → (i : ℕ) → (s : Lean.Expr) → motive (Lean.Expr.proj n i s)) →
((f arg : Lean.Expr) → motive (f.app arg)) →
((mvarId : Lean.MVarId) → motive (Lean.Expr.mvar mvarId)) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) →
((bidx : ℕ) → motive (Lean.Expr.bvar bidx)) →
((data : Lean.MData) → (e : Lean.Expr) → motive (Lean.Expr.mdata data e)) →
((v : Lean.Literal) → motive (Lean.Expr.lit v)) →
((lvl : Lean.Level) → motive (Lean.Expr.sort lvl)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) →
motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) →
motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((declName : Lean.Name) →
(type value body : Lean.Expr) →
(nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
motive e |
_private.Mathlib.RingTheory.Unramified.Finite.0.Algebra.FormallyUnramified.finite_of_free_aux._simp_1_2 | Mathlib.RingTheory.Unramified.Finite | ∀ {M : Type u_1} {N : Type u_2} {γ : Type u_3} [inst : AddCommMonoid N] [inst_1 : DistribSMul M N] {r : M} {f : γ → N}
{s : Finset γ}, ∑ x ∈ s, r • f x = r • ∑ x ∈ s, f x |
AffineEquiv.mk.sizeOf_spec | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_4} {V₂ : Type u_5} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : AddCommGroup V₂] [inst_3 : Module k V₁] [inst_4 : Module k V₂]
[inst_5 : AddTorsor V₁ P₁] [inst_6 : AddTorsor V₂ P₂] [inst_7 : SizeOf k] [inst_8 : SizeOf P₁] [inst_9 : SizeOf P₂]
[inst_10 : SizeOf V₁] [inst_11 : SizeOf V₂] (toEquiv : P₁ ≃ P₂) (linear : V₁ ≃ₗ[k] V₂)
(map_vadd' : ∀ (p : P₁) (v : V₁), toEquiv (v +ᵥ p) = linear v +ᵥ toEquiv p),
sizeOf { toEquiv := toEquiv, linear := linear, map_vadd' := map_vadd' } = 1 + sizeOf toEquiv + sizeOf linear |
_private.Mathlib.CategoryTheory.Limits.Shapes.Biproducts.0.CategoryTheory.Limits.biproduct.isoProduct_inv._simp_1_1 | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp α.inv f = g) = (f = CategoryTheory.CategoryStruct.comp α.hom g) |
ULift.field._proof_9 | Mathlib.Algebra.Field.ULift | ∀ {α : Type u_2} [inst : Field α] (q : ℚ≥0) (a : ULift.{u_1, u_2} α), DivisionRing.nnqsmul q a = ↑q * a |
Filter.IsCountableBasis.casesOn | Mathlib.Order.Filter.CountablyGenerated | {α : Type u_1} →
{ι : Type u_4} →
{p : ι → Prop} →
{s : ι → Set α} →
{motive : Filter.IsCountableBasis p s → Sort u} →
(t : Filter.IsCountableBasis p s) →
((toIsBasis : Filter.IsBasis p s) → (countable : (setOf p).Countable) → motive ⋯) → motive t |
CategoryTheory.Balanced.isIso_of_mono_of_epi | Mathlib.CategoryTheory.Balanced | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.Balanced C] {X Y : C} (f : X ⟶ Y)
[CategoryTheory.Mono f] [CategoryTheory.Epi f], CategoryTheory.IsIso f |
SmoothPartitionOfUnity.casesOn | Mathlib.Geometry.Manifold.PartitionOfUnity | {ι : Type uι} →
{E : Type uE} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
{H : Type uH} →
[inst_2 : TopologicalSpace H] →
{I : ModelWithCorners ℝ E H} →
{M : Type uM} →
[inst_3 : TopologicalSpace M] →
[inst_4 : ChartedSpace H M] →
{s : Set M} →
{motive : SmoothPartitionOfUnity ι I M s → Sort u} →
(t : SmoothPartitionOfUnity ι I M s) →
((toFun : ι → ContMDiffMap I (modelWithCornersSelf ℝ ℝ) M ℝ ↑⊤) →
(locallyFinite' : LocallyFinite fun i => Function.support ⇑(toFun i)) →
(nonneg' : ∀ (i : ι) (x : M), 0 ≤ (toFun i) x) →
(sum_eq_one' : ∀ x ∈ s, ∑ᶠ (i : ι), (toFun i) x = 1) →
(sum_le_one' : ∀ (x : M), ∑ᶠ (i : ι), (toFun i) x ≤ 1) →
motive
{ toFun := toFun, locallyFinite' := locallyFinite', nonneg' := nonneg',
sum_eq_one' := sum_eq_one', sum_le_one' := sum_le_one' }) →
motive t |
Valuation.IsEquiv.valueGroup₀Fun._proof_3 | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_2} {Γ₀ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : Ring R] {v : Valuation R Γ₀}
(d : { xy // v xy.1 ≠ 0 ∧ v xy.2 ≠ 0 }), v (↑d).2 ≠ 0 |
MeasurableDiv₂.rec | Mathlib.MeasureTheory.Group.Arithmetic | {G₀ : Type u_2} →
[inst : MeasurableSpace G₀] →
[inst_1 : Div G₀] →
{motive : MeasurableDiv₂ G₀ → Sort u} →
((measurable_div : Measurable fun p => p.1 / p.2) → motive ⋯) → (t : MeasurableDiv₂ G₀) → motive t |
Std.TreeMap.Raw.Equiv.entryAtIdxD_eq | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp] {i : ℕ}
{fallback : α × β}, t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.entryAtIdxD i fallback = t₂.entryAtIdxD i fallback |
Perfection.teichmuller | Mathlib.RingTheory.Teichmuller | (p : ℕ) →
[inst : Fact (Nat.Prime p)] →
{R : Type u_1} →
[inst_1 : CommRing R] →
(I : Ideal R) → [inst_2 : CharP (R ⧸ I) p] → [IsAdicComplete I R] → Perfection (R ⧸ I) p →* R |
MeasureTheory.Lp.compMeasurePreserving._proof_2 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_2} {E : Type u_1} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] {β : Type u_3} [inst_1 : MeasurableSpace β] {μb : MeasureTheory.Measure β} (f : α → β)
(hf : MeasureTheory.MeasurePreserving f μ μb) (g : ↥(MeasureTheory.Lp E p μb)),
(↑g).compMeasurePreserving f hf ∈ MeasureTheory.Lp E p μ |
Bundle.Trivialization.contMDiffOn_iff | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {n : WithTop ℕ∞} {𝕜 : Type u_1} {B : Type u_2} {F : Type u_4} {M : Type u_5} {E : B → Type u_6}
[inst : NontriviallyNormedField 𝕜] {EB : Type u_7} [inst_1 : NormedAddCommGroup EB] [inst_2 : NormedSpace 𝕜 EB]
{HB : Type u_8} [inst_3 : TopologicalSpace HB] {IB : ModelWithCorners 𝕜 EB HB} [inst_4 : TopologicalSpace B]
[inst_5 : ChartedSpace HB B] {EM : Type u_9} [inst_6 : NormedAddCommGroup EM] [inst_7 : NormedSpace 𝕜 EM]
{HM : Type u_10} [inst_8 : TopologicalSpace HM] {IM : ModelWithCorners 𝕜 EM HM} [inst_9 : TopologicalSpace M]
[inst_10 : ChartedSpace HM M] [inst_11 : (x : B) → AddCommMonoid (E x)] [inst_12 : (x : B) → Module 𝕜 (E x)]
[inst_13 : NormedAddCommGroup F] [inst_14 : NormedSpace 𝕜 F] [inst_15 : TopologicalSpace (Bundle.TotalSpace F E)]
[inst_16 : (x : B) → TopologicalSpace (E x)] [inst_17 : FiberBundle F E] [inst_18 : VectorBundle 𝕜 F E]
[ContMDiffVectorBundle n F E IB] {e : Bundle.Trivialization F Bundle.TotalSpace.proj} [MemTrivializationAtlas e]
{f : M → Bundle.TotalSpace F E} {s : Set M},
Set.MapsTo f s e.source →
(ContMDiffOn IM (IB.prod (modelWithCornersSelf 𝕜 F)) n f s ↔
ContMDiffOn IM IB n (fun x => (f x).proj) s ∧
ContMDiffOn IM (modelWithCornersSelf 𝕜 F) n (fun x => (↑e (f x)).2) s) |
Char.instLawfulUpwardEnumerableLE | Init.Data.Range.Polymorphic.Char | Std.PRange.LawfulUpwardEnumerableLE Char |
_private.Mathlib.MeasureTheory.Function.AbsolutelyContinuous.0.AbsolutelyContinuousOnInterval.hasBasis_totalLengthFilter._simp_1_3 | Mathlib.MeasureTheory.Function.AbsolutelyContinuous | ∀ {p q : Prop}, (p ↔ q ∧ p) = (p → q) |
Std.HashMap.Raw.mem_of_mem_insertMany_list | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
m.WF → ∀ {l : List (α × β)} {k : α}, k ∈ m.insertMany l → (List.map Prod.fst l).contains k = false → k ∈ m |
instZeroEuclideanQuadrant | Mathlib.Geometry.Manifold.Instances.Real | {n : ℕ} → Zero (EuclideanQuadrant n) |
HomologicalComplex.restrictionHomologyIso_hom_homologyι_assoc | 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 : ι) (hi : c.prev j = i)
(hk : c.next 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') [inst_3 : K.HasHomology j'] [inst_4 : (K.restriction e).HasHomology j] {Z : C}
(h : K.opcycles j' ⟶ Z),
CategoryTheory.CategoryStruct.comp (K.restrictionHomologyIso e i j k hi hk hi' hj' hk' hi'' hk'').hom
(CategoryTheory.CategoryStruct.comp (K.homologyι j') h) =
CategoryTheory.CategoryStruct.comp ((K.restriction e).homologyι j)
(CategoryTheory.CategoryStruct.comp (K.restrictionOpcyclesIso e i j hi hi' hj' hi'').hom h) |
LocallyConstant.charFn | Mathlib.Topology.LocallyConstant.Algebra | {X : Type u_1} →
(Y : Type u_2) → [inst : TopologicalSpace X] → [MulZeroOneClass Y] → {U : Set X} → IsClopen U → LocallyConstant X Y |
WithLp.ctorIdx | Mathlib.Analysis.Normed.Lp.WithLp | {p : ENNReal} → {V : Type u_1} → WithLp p V → ℕ |
Bool.sizeOf_eq_one | Init.SizeOf | ∀ (b : Bool), sizeOf b = 1 |
Filter.isBoundedUnder_ge_inf._simp_1 | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} [inst : SemilatticeInf α] {f : Filter β} {u v : β → α},
(Filter.IsBoundedUnder (fun x1 x2 => x1 ≥ x2) f fun a => u a ⊓ v a) =
(Filter.IsBoundedUnder (fun x1 x2 => x1 ≥ x2) f u ∧ Filter.IsBoundedUnder (fun x1 x2 => x1 ≥ x2) f v) |
MvPolynomial.support_sum | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {α : Type u_2} [inst_1 : DecidableEq σ] {s : Finset α}
{f : α → MvPolynomial σ R}, (∑ x ∈ s, f x).support ⊆ s.biUnion fun x => (f x).support |
Set.mulIndicator_one | Mathlib.Algebra.Notation.Indicator | ∀ {α : Type u_1} (M : Type u_3) [inst : One M] (s : Set α), (s.mulIndicator fun x => 1) = fun x => 1 |
CategoryTheory.Limits.pushout.map._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {W X Y Z S T : C} (f₁ : S ⟶ W) (f₂ : S ⟶ X) (g₁ : T ⟶ Y)
(g₂ : T ⟶ Z) [inst_1 : CategoryTheory.Limits.HasPushout g₁ g₂] (i₁ : W ⟶ Y) (i₂ : X ⟶ Z) (i₃ : S ⟶ T),
CategoryTheory.CategoryStruct.comp f₁ i₁ = CategoryTheory.CategoryStruct.comp i₃ g₁ →
CategoryTheory.CategoryStruct.comp f₂ i₂ = CategoryTheory.CategoryStruct.comp i₃ g₂ →
CategoryTheory.CategoryStruct.comp f₁
(CategoryTheory.CategoryStruct.comp i₁ (CategoryTheory.Limits.pushout.inl g₁ g₂)) =
CategoryTheory.CategoryStruct.comp f₂
(CategoryTheory.CategoryStruct.comp i₂ (CategoryTheory.Limits.pushout.inr g₁ g₂)) |
Lean.Meta.Grind.checkMaxEmatchExceeded | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.GoalM Bool |
Batteries.AssocList.isEmpty.eq_1 | Batteries.Data.AssocList | ∀ {α : Type u_1} {β : Type u_2}, Batteries.AssocList.nil.isEmpty = true |
Aesop.RuleTacDescr.constructors | Aesop.RuleTac.Descr | Array Lean.Name → Lean.Meta.TransparencyMode → Aesop.RuleTacDescr |
div_lt_div_iff' | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : CommGroup α] [inst_1 : LT α] [MulLeftStrictMono α] {a b c d : α}, a / b < c / d ↔ a * d < c * b |
Module.Basis.empty.congr_simp | Mathlib.RingTheory.Smooth.StandardSmoothOfFree | ∀ {ι : Type u_1} {R : Type u_3} (M : Type u_5) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Subsingleton M] [inst_4 : IsEmpty ι], Module.Basis.empty M = Module.Basis.empty M |
SNum.lt | Mathlib.Data.Num.Lemmas | LT SNum |
Std.DTreeMap.Internal.Impl.mem_of_mem_erase! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF → ∀ {k a : α}, a ∈ Std.DTreeMap.Internal.Impl.erase! k t → a ∈ t |
String.Slice.Pos.prevAux.go.eq_def | Init.Data.String.Basic | ∀ {s : String.Slice} (off : ℕ) (h₁ : off < s.utf8ByteSize),
String.Slice.Pos.prevAux.go off h₁ =
if hbyte : (s.getUTF8Byte { byteIdx := off } h₁).IsUTF8FirstByte then { byteIdx := off }
else
have this := ⋯;
match off, h₁, hbyte, this with
| 0, h₁, hbyte, this => ⋯.elim
| off.succ, h₁, hbyte, this => String.Slice.Pos.prevAux.go off ⋯ |
CategoryTheory.WithTerminal.starIsoTerminal_inv | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C],
CategoryTheory.WithTerminal.starIsoTerminal.inv =
CategoryTheory.WithTerminal.starTerminal.from (⊤_ CategoryTheory.WithTerminal C) |
Homeomorph.setCongr._proof_2 | Mathlib.Topology.Homeomorph.Lemmas | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s t : Set X} (h : s = t), Continuous (Set.inclusion ⋯) |
uniformity_pseudoedist | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u} [inst : PseudoEMetricSpace α],
uniformity α = ⨅ ε, ⨅ (_ : ε > 0), Filter.principal {p | edist p.1 p.2 < ε} |
RootPairing.PolarizationEquiv._proof_5 | Mathlib.LinearAlgebra.RootSystem.Finite.Nondegenerate | ∀ {R : Type u_1} [inst : Field R], RingHomInvPair (RingHom.id R) (RingHom.id R) |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.instBEqSplitStatus.beq._sparseCasesOn_3 | Lean.Meta.Tactic.Grind.Split | {motive : Lean.Meta.Grind.SplitStatus → Sort u} →
(t : Lean.Meta.Grind.SplitStatus) →
((numCases : ℕ) →
(isRec tryPostpone : Bool) → motive (Lean.Meta.Grind.SplitStatus.ready numCases isRec tryPostpone)) →
(Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t |
Orientation.eq_rotation_self_iff | Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x : V) (θ : Real.Angle), x = (o.rotation θ) x ↔ x = 0 ∨ θ = 0 |
Applicative.mk.noConfusion | Init.Prelude | {f : Type u → Type v} →
{P : Sort u_1} →
{toFunctor : Functor f} →
{toPure : Pure f} →
{toSeq : Seq f} →
{toSeqLeft : SeqLeft f} →
{toSeqRight : SeqRight f} →
{toFunctor' : Functor f} →
{toPure' : Pure f} →
{toSeq' : Seq f} →
{toSeqLeft' : SeqLeft f} →
{toSeqRight' : SeqRight f} →
{ toFunctor := toFunctor, toPure := toPure, toSeq := toSeq, toSeqLeft := toSeqLeft,
toSeqRight := toSeqRight } =
{ toFunctor := toFunctor', toPure := toPure', toSeq := toSeq', toSeqLeft := toSeqLeft',
toSeqRight := toSeqRight' } →
(toFunctor ≍ toFunctor' →
toPure ≍ toPure' →
toSeq ≍ toSeq' → toSeqLeft ≍ toSeqLeft' → toSeqRight ≍ toSeqRight' → P) →
P |
AlgebraicGeometry.Scheme.ProEt.instFullOverForget | Mathlib.AlgebraicGeometry.Sites.Proetale | ∀ (S : AlgebraicGeometry.Scheme), (AlgebraicGeometry.Scheme.ProEt.forget S).Full |
Std.Stream.noConfusion | Init.Data.Stream | {P : Sort u_1} →
{stream : Type u} →
{value : Type v} →
{t : Std.Stream stream value} →
{stream' : Type u} →
{value' : Type v} →
{t' : Std.Stream stream' value'} →
stream = stream' → value = value' → t ≍ t' → Std.Stream.noConfusionType P t t' |
Complex.differentiable_sinh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | Differentiable ℂ Complex.sinh |
ONote.fundamentalSequenceProp_inl_some | Mathlib.SetTheory.Ordinal.Notation | ∀ (o a : ONote), o.FundamentalSequenceProp (Sum.inl (some a)) ↔ o.repr = Order.succ a.repr ∧ (o.NF → a.NF) |
LocallyConstant.instMul.eq_1 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : Mul Y],
LocallyConstant.instMul = { mul := fun f g => { toFun := ⇑f * ⇑g, isLocallyConstant := ⋯ } } |
Lean.Parser.withOpenDeclFn | Lean.Parser.Extension | Lean.Parser.ParserFn → Lean.Parser.ParserFn |
ValuativeRel.ValueGroupWithZero.mk_one_one | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R], ValuativeRel.ValueGroupWithZero.mk 1 1 = 1 |
Module.Basis.algebraMapCoeffs_apply | Mathlib.RingTheory.AlgebraTower | ∀ {R : Type u_1} (A : Type u_3) {ι : Type u_5} {M : Type u_6} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : AddCommMonoid M] [inst_3 : Algebra R A] [inst_4 : Module A M] [inst_5 : Module R M]
[inst_6 : IsScalarTower R A M] (b : Module.Basis ι R M) (h : Function.Bijective ⇑(algebraMap R A)) (i : ι),
(Module.Basis.algebraMapCoeffs A b h) i = b i |
ContinuousLinearMap.mfderiv_eq | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_5} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E']
(f : E →L[𝕜] E') {x : E}, mfderiv% ⇑f x = f |
OrderIso.isBoundedUnder_le_comp | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : LE α] [inst_1 : LE β] (e : α ≃o β) {l : Filter γ} {u : γ → α},
(Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) l fun x => e (u x)) ↔ Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) l u |
Left.nsmul_nonpos | Mathlib.Algebra.Order.Monoid.Unbundled.Pow | ∀ {M : Type u_3} [inst : AddMonoid M] [inst_1 : Preorder M] [AddLeftMono M] {a : M}, a ≤ 0 → ∀ (n : ℕ), n • a ≤ 0 |
Lean.Elab.Tactic.GuardMsgs.GuardMsgsSpec._sizeOf_1 | Lean.Elab.GuardMsgs | Lean.Elab.Tactic.GuardMsgs.GuardMsgsSpec → ℕ |
_private.Mathlib.LinearAlgebra.LinearIndependent.Defs.0.not_linearIndependent_iffₛ._simp_1_2 | Mathlib.LinearAlgebra.LinearIndependent.Defs | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x |
_private.Mathlib.Topology.Instances.ENNReal.Lemmas.0.ENNReal.continuous_pow._simp_1_1 | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {y : Y},
(Continuous fun x => y) = True |
Int.natAbs_one | Init.Data.Int.Order | Int.natAbs 1 = 1 |
RingAut.toAddAut._proof_1 | Mathlib.Algebra.Ring.Aut | ∀ (R : Type u_1) [inst : Mul R] [inst_1 : Add R], RingEquiv.toAddEquiv 1 = RingEquiv.toAddEquiv 1 |
Matrix.submatrixEquivInvertible._proof_1 | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {m : Type u_3} {n : Type u_1} {α : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α]
[inst_3 : Fintype m] [inst_4 : DecidableEq m] (A : Matrix m m α) (e₁ e₂ : n ≃ m) [inst_5 : Invertible A],
A.submatrix ⇑e₁ ⇑e₂ * (⅟A).submatrix ⇑e₂ ⇑e₁ = 1 |
NormedAddGroupHom.inhabited | Mathlib.Analysis.Normed.Group.Hom | {V₁ : Type u_2} →
{V₂ : Type u_3} →
[inst : SeminormedAddCommGroup V₁] → [inst_1 : SeminormedAddCommGroup V₂] → Inhabited (NormedAddGroupHom V₁ V₂) |
MulArchimedeanClass.liftOrderHom.eq_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M] {α : Type u_2}
[inst_3 : PartialOrder α] (f : M → α)
(h : ∀ (a b : M), MulArchimedeanClass.mk a ≤ MulArchimedeanClass.mk b → f a ≤ f b),
MulArchimedeanClass.liftOrderHom f h = { toFun := MulArchimedeanClass.lift f ⋯, monotone' := ⋯ } |
LieAlgebra.Orthogonal.soIndefiniteEquiv._proof_1 | Mathlib.Algebra.Lie.Classical | ∀ (p : Type u_1) (q : Type u_2) (R : Type u_3) [inst : DecidableEq p] [inst_1 : DecidableEq q] [inst_2 : CommRing R]
[inst_3 : Fintype p] [inst_4 : Fintype q] {i : R},
i * i = -1 →
↑(skewAdjointMatricesLieSubalgebra
((LieAlgebra.Orthogonal.Pso p q R i).transpose * LieAlgebra.Orthogonal.indefiniteDiagonal p q R *
LieAlgebra.Orthogonal.Pso p q R i)) =
↑(LieAlgebra.Orthogonal.so (p ⊕ q) R) |
AbstractCompletion.extend_unique | Mathlib.Topology.UniformSpace.AbstractCompletion | ∀ {α : Type uα} [inst : UniformSpace α] (pkg : AbstractCompletion.{vα, uα} α) {β : Type uβ} [inst_1 : UniformSpace β]
{f : α → β} [CompleteSpace β] [T0Space β],
UniformContinuous f → ∀ {g : pkg.space → β}, UniformContinuous g → (∀ (a : α), f a = g (pkg.coe a)) → pkg.extend f = g |
Set.mem_cIcc | Mathlib.Order.Circular | ∀ {α : Type u_1} [inst : CircularPreorder α] {a b x : α}, x ∈ Set.cIcc a b ↔ btw a x b |
Asymptotics.IsBigOTVS.add | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] [ContinuousAdd E] [ContinuousSMul 𝕜 E] {f₁ f₂ : α → E} {g : α → F}
{l : Filter α}, f₁ =O[𝕜; l] g → f₂ =O[𝕜; l] g → (f₁ + f₂) =O[𝕜; l] g |
OrderMonoidIso.unitsCongr | Mathlib.Algebra.Order.Hom.Units | {α : Type u_1} →
{β : Type u_2} →
[inst : Preorder α] → [inst_1 : Monoid α] → [inst_2 : Preorder β] → [inst_3 : Monoid β] → (α ≃*o β) → αˣ ≃*o βˣ |
thickenedIndicatorAux.eq_1 | Mathlib.Topology.MetricSpace.ThickenedIndicator | ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] (δ : ℝ) (E : Set α) (x : α),
thickenedIndicatorAux δ E x = 1 - Metric.infEDist x E / ENNReal.ofReal δ |
ValuationSubring.primeSpectrumEquiv_apply | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] (A : ValuationSubring K) (P : PrimeSpectrum ↥A),
A.primeSpectrumEquiv P = ⟨A.ofPrime P.asIdeal, ⋯⟩ |
Std.DTreeMap.Raw.ordered_keys | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → List.Pairwise (fun a b => cmp a b = Ordering.lt) t.keys |
_private.Mathlib.CategoryTheory.Subfunctor.Basic.0.CategoryTheory.instCompleteLatticeSubfunctor._simp_5 | Mathlib.CategoryTheory.Subfunctor.Basic | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i |
Metric.sphere_subset_closedBall | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, Metric.sphere x ε ⊆ Metric.closedBall x ε |
Complex.tsum_exp_neg_quadratic | Mathlib.Analysis.SpecialFunctions.Gaussian.PoissonSummation | ∀ {a : ℂ},
0 < a.re →
∀ (b : ℂ),
∑' (n : ℤ), Complex.exp (-↑Real.pi * a * ↑n ^ 2 + 2 * ↑Real.pi * b * ↑n) =
1 / a ^ (1 / 2) * ∑' (n : ℤ), Complex.exp (-↑Real.pi / a * (↑n + Complex.I * b) ^ 2) |
exists_isClopen_upper_or_lower_of_ne | Mathlib.Topology.Order.Priestley | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : PartialOrder α] [PriestleySpace α] {x y : α},
x ≠ y → ∃ U, IsClopen U ∧ (IsUpperSet U ∨ IsLowerSet U) ∧ x ∈ U ∧ y ∉ U |
DFinsupp.coe_sup | Mathlib.Data.DFinsupp.Order | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] [inst_1 : (i : ι) → SemilatticeSup (α i)]
(f g : Π₀ (i : ι), α i), ⇑(f ⊔ g) = ⇑f ⊔ ⇑g |
CategoryTheory.op_add | Mathlib.CategoryTheory.Preadditive.Opposite | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
(f g : X ⟶ Y), (f + g).op = f.op + g.op |
Std.DHashMap.Internal.Raw₀.replaceₘ._proof_1 | Std.Data.DHashMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} [inst : BEq α] [inst_1 : Hashable α] (m : Std.DHashMap.Internal.Raw₀ α β) (a : α)
(b : β a),
0 <
{ size := (↑m).size,
buckets :=
Std.DHashMap.Internal.updateBucket (↑m).buckets ⋯ a fun l =>
Std.DHashMap.Internal.AssocList.replace a b l }.buckets.size |
RCLike.continuous_im | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], Continuous ⇑RCLike.im |
Std.Iterators.Types.Flatten.IsPlausibleStep.outerDone_flatMap | Init.Data.Iterators.Lemmas.Combinators.Monadic.FlatMap | ∀ {α β α₂ γ : Type w} {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α m β]
[inst_3 : Std.Iterator α₂ m γ] {f : β → Std.IterM m γ} {it₁ : Std.IterM m β},
it₁.IsPlausibleStep Std.IterStep.done → (Std.IterM.flatMapAfter f it₁ none).IsPlausibleStep Std.IterStep.done |
_private.Mathlib.Algebra.Homology.Augment.0.ChainComplex.augment.match_3.splitter | Mathlib.Algebra.Homology.Augment | (motive : ℕ → ℕ → Sort u_1) →
(x x_1 : ℕ) →
(Unit → motive 1 0) →
((i j : ℕ) → motive i.succ j.succ) →
((x x_2 : ℕ) → (x = 1 → x_2 = 0 → False) → (∀ (i j : ℕ), x = i.succ → x_2 = j.succ → False) → motive x x_2) →
motive x x_1 |
MonoidAlgebra.liftMagma._proof_2 | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ (R : Type u_3) {A : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : Mul M]
[inst_2 : NonUnitalNonAssocSemiring A] [inst_3 : Module R A] [IsScalarTower R A A] [SMulCommClass R A A] (f : M →ₙ* A)
(a₁ a₂ : MonoidAlgebra R M),
(Finsupp.sum (a₁ * a₂) fun m t => t • f m) = (Finsupp.sum a₁ fun m t => t • f m) * Finsupp.sum a₂ fun m t => t • f m |
_private.Lean.Elab.Tactic.NormCast.0.Lean.Elab.Tactic.NormCast.splittingProcedure.match_1 | Lean.Elab.Tactic.NormCast | (motive : Option Lean.Meta.Simp.Result → Sort u_1) →
(__discr : Option Lean.Meta.Simp.Result) →
((x_x2 : Lean.Meta.Simp.Result) → motive (some x_x2)) →
((x : Option Lean.Meta.Simp.Result) → motive x) → motive __discr |
Functor.map_comp_map | Mathlib.Control.Functor | ∀ {F : Type u → Type v} {α β γ : Type u} [inst : Functor F] [LawfulFunctor F] (f : α → β) (g : β → γ),
((fun x => g <$> x) ∘ fun x => f <$> x) = fun x => (g ∘ f) <$> x |
CategoryTheory.ComposableArrows.threeδ₁Toδ₀_app_zero | Mathlib.CategoryTheory.ComposableArrows.Three | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {i j k l : C} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l)
(f₁₂ : i ⟶ k) (h₁₂ : CategoryTheory.CategoryStruct.comp f₁ f₂ = f₁₂),
(CategoryTheory.ComposableArrows.threeδ₁Toδ₀ f₁ f₂ f₃ f₁₂ h₁₂).app 0 = f₁ |
CategoryTheory.Oplax.StrongTrans.Modification.ext_iff | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | ∀ {B : Type u₁} {inst : CategoryTheory.Bicategory B} {C : Type u₂} {inst_1 : CategoryTheory.Bicategory C}
{F G : CategoryTheory.OplaxFunctor B C} {η θ : F ⟶ G} {x y : CategoryTheory.Oplax.StrongTrans.Modification η θ},
x = y ↔ x.app = y.app |
Polynomial.reflect_mul_induction | Mathlib.Algebra.Polynomial.Reverse | ∀ {R : Type u_1} [inst : Semiring R] (cf cg N O : ℕ) (f g : Polynomial R),
f.support.card ≤ cf.succ →
g.support.card ≤ cg.succ →
f.natDegree ≤ N →
g.natDegree ≤ O → Polynomial.reflect (N + O) (f * g) = Polynomial.reflect N f * Polynomial.reflect O g |
CategoryTheory.typeEquiv_unitIso_inv_app | Mathlib.CategoryTheory.Sites.Types | ∀ (X : Type u)
(a :
(CategoryTheory.yoneda'.comp
((CategoryTheory.sheafToPresheaf CategoryTheory.typesGrothendieckTopology (Type u)).comp
((CategoryTheory.evaluation Type uᵒᵖ (Type u)).obj (Opposite.op PUnit.{u + 1})))).obj
X),
CategoryTheory.typeEquiv.unitIso.inv.app X a = a PUnit.unit |
_private.Lean.Server.FileWorker.0.Lean.Server.FileWorker.handlePreRequestSpecialCases?.match_3 | Lean.Server.FileWorker | (motive : String → Sort u_1) →
(method : String) →
(Unit → motive "$/lean/rpc/call") → (Unit → motive "codeAction/resolve") → ((x : String) → motive x) → motive method |
CategoryTheory.Limits.Cone.functoriality_obj_pt | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{D : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} D] (F : CategoryTheory.Functor J C)
(G : CategoryTheory.Functor C D) (A : CategoryTheory.Limits.Cone F),
((CategoryTheory.Limits.Cone.functoriality F G).obj A).pt = G.obj A.pt |
_private.Mathlib.Logic.Equiv.Defs.0.Equiv.permCongr_trans._proof_1_1 | Mathlib.Logic.Equiv.Defs | ∀ {α' : Type u_2} {β' : Type u_1} (e : α' ≃ β') (p p' : Equiv.Perm α'),
(e.permCongr p).trans (e.permCongr p') = e.permCongr (Equiv.trans p p') |
Int.gcd_comm | Init.Data.Int.Gcd | ∀ (a b : ℤ), a.gcd b = b.gcd a |
Algebra.Extension.tensorCotangentSpaceOfFormallyEtale._proof_7 | Mathlib.RingTheory.Etale.Kaehler | ∀ {R : Type u_4} {S : Type u_1} {T : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R T] [inst_4 : Algebra S T] {Q : Algebra.Extension R T}, SMulCommClass S Q.Ring T |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.