name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
LinearMap.tensorEqLocusBil._proof_12 | Mathlib.RingTheory.Flat.Equalizer | ∀ {R : Type u_1} (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (M : Type u_3)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M] {N : Type u_4}
{P : Type u_5} [inst_7 : AddCommGroup N] [inst_8 : AddCommGroup P] [inst_9 : Module R N] [inst_10 : Module R P]
(f g : N →ₗ[R] P),
SMulCommClass R S
↥(LinearMap.eqLocus ((TensorProduct.AlgebraTensorModule.lTensor S M) f)
((TensorProduct.AlgebraTensorModule.lTensor S M) g)) |
Option.isSome.eq_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} (val : α), (some val).isSome = true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.cons_append_append._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w₁ w₂ w₃ : ℕ}, ∀ i < w₁ + 1 + w₂ + w₃, ¬i < w₁ + w₂ + w₃ → i - w₃ - w₂ < w₁ → False |
_private.Lean.Elab.Deriving.DecEq.0.Lean.Elab.Deriving.DecEq.mkMatchOld.mkSameCtorRhs._unsafe_rec | Lean.Elab.Deriving.DecEq | List (Lean.Ident × Lean.Ident × Option Lean.Name × Bool) → Lean.Elab.TermElabM Lean.Term |
Lean.Lsp.instFromJsonPosition | Lean.Data.Lsp.BasicAux | Lean.FromJson Lean.Lsp.Position |
CategoryTheory.SimplicialThickening.Path.mk.inj | Mathlib.AlgebraicTopology.SimplicialNerve | ∀ {J : Type u_1} {inst : LinearOrder J} {i j : J} {I : Set J}
{left : autoParam (i ∈ I) CategoryTheory.SimplicialThickening.Path.left._autoParam}
{right : autoParam (j ∈ I) CategoryTheory.SimplicialThickening.Path.right._autoParam}
{left_le : autoParam (∀ k ∈ I, i ≤ k) CategoryTheory.SimplicialThickening.Path.left_le._autoParam}
{le_right : autoParam (∀ k ∈ I, k ≤ j) CategoryTheory.SimplicialThickening.Path.le_right._autoParam} {I_1 : Set J}
{left_1 : autoParam (i ∈ I_1) CategoryTheory.SimplicialThickening.Path.left._autoParam}
{right_1 : autoParam (j ∈ I_1) CategoryTheory.SimplicialThickening.Path.right._autoParam}
{left_le_1 : autoParam (∀ k ∈ I_1, i ≤ k) CategoryTheory.SimplicialThickening.Path.left_le._autoParam}
{le_right_1 : autoParam (∀ k ∈ I_1, k ≤ j) CategoryTheory.SimplicialThickening.Path.le_right._autoParam},
{ I := I, left := left, right := right, left_le := left_le, le_right := le_right } =
{ I := I_1, left := left_1, right := right_1, left_le := left_le_1, le_right := le_right_1 } →
I = I_1 |
AddSubgroup.instTop.eq_1 | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : AddGroup G],
AddSubgroup.instTop =
{
top :=
let __src := ⊤;
{ toAddSubmonoid := __src, neg_mem' := ⋯ } } |
Lean.Parser.Attr._aux_Mathlib_Tactic_Simps_Basic___macroRules_Lean_Parser_Attr_attrSimps!?__1 | Mathlib.Tactic.Simps.Basic | Lean.Macro |
IntermediateField.copy | Mathlib.FieldTheory.IntermediateField.Basic | {K : Type u_1} →
{L : Type u_2} →
[inst : Field K] →
[inst_1 : Field L] →
[inst_2 : Algebra K L] → (S : IntermediateField K L) → (s : Set L) → s = ↑S → IntermediateField K L |
Sublattice.comap | Mathlib.Order.Sublattice | {α : Type u_2} →
{β : Type u_3} → [inst : Lattice α] → [inst_1 : Lattice β] → LatticeHom α β → Sublattice β → Sublattice α |
Finsupp.smul_single | Mathlib.Data.Finsupp.SMulWithZero | ∀ {α : Type u_1} {M : Type u_5} {R : Type u_11} [inst : Zero M] [inst_1 : SMulZeroClass R M] (c : R) (a : α) (b : M),
(c • fun₀ | a => b) = fun₀ | a => c • b |
CategoryTheory.GrothendieckTopology.isoToPlus.congr_simp | Mathlib.CategoryTheory.Sites.Plus | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type w}
[inst_1 : CategoryTheory.Category.{w', w} D]
[inst_2 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
(P : CategoryTheory.Functor Cᵒᵖ D) [inst_3 : ∀ (X : C), CategoryTheory.Limits.HasColimitsOfShape (J.Cover X)ᵒᵖ D]
(hP : CategoryTheory.Presheaf.IsSheaf J P), J.isoToPlus P hP = J.isoToPlus P hP |
PFunctor.M.bisim' | Mathlib.Data.PFunctor.Univariate.M | ∀ {P : PFunctor.{uA, uB}} {α : Type u_3} (Q : α → Prop) (u v : α → P.M),
(∀ (x : α),
Q x →
∃ a f f', (u x).dest = ⟨a, f⟩ ∧ (v x).dest = ⟨a, f'⟩ ∧ ∀ (i : P.B a), ∃ x', Q x' ∧ f i = u x' ∧ f' i = v x') →
∀ (x : α), Q x → u x = v x |
Asymptotics.isBigO_top._simp_1 | Mathlib.Analysis.Asymptotics.Lemmas | ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F},
f =O[⊤] g = ∃ C, ∀ (x : α), ‖f x‖ ≤ C * ‖g x‖ |
CategoryTheory.OrthogonalReflection.D₁.ιLeft_comp_t_assoc | Mathlib.CategoryTheory.Presentable.OrthogonalReflection | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} {Z : C}
[inst_1 : CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₁]
[inst_2 : CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₂] {X Y : C} (f : X ⟶ Y)
(hf : W f) (g : X ⟶ Z) {Z_1 : C} (h : ∐ CategoryTheory.OrthogonalReflection.D₁.obj₂ ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.OrthogonalReflection.D₁.ιLeft f hf g)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.OrthogonalReflection.D₁.t W Z) h) =
CategoryTheory.CategoryStruct.comp f
(CategoryTheory.CategoryStruct.comp (CategoryTheory.OrthogonalReflection.D₁.ιRight f hf g) h) |
CategoryTheory.Dial.recOn | Mathlib.CategoryTheory.Dialectica.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasFiniteProducts C] →
{motive : CategoryTheory.Dial C → Sort u_1} →
(t : CategoryTheory.Dial C) →
((src tgt : C) →
(rel : CategoryTheory.Subobject (src ⨯ tgt)) → motive { src := src, tgt := tgt, rel := rel }) →
motive t |
List.length_destutter_le_length_destutter_cons | Mathlib.Data.List.Destutter | ∀ {α : Type u_1} {R : α → α → Prop} [inst : DecidableRel R] {a : α} [IsEquiv α Rᶜ] {l : List α},
(List.destutter R l).length ≤ (List.destutter R (a :: l)).length |
StarSubsemiring.center | Mathlib.Algebra.Star.Subsemiring | (R : Type u_1) → [inst : NonAssocSemiring R] → [inst_1 : StarRing R] → StarSubsemiring R |
Subtype.coe_bot | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} {p : α → Prop} [inst : PartialOrder α] [inst_1 : OrderBot α] [inst_2 : OrderBot (Subtype p)],
p ⊥ → ↑⊥ = ⊥ |
Finset.map_swap_antidiagonal | Mathlib.Algebra.Order.Antidiag.Prod | ∀ {A : Type u_1} [inst : AddCommMonoid A] [inst_1 : Finset.HasAntidiagonal A] {n : A},
Finset.map { toFun := Prod.swap, inj' := ⋯ } (Finset.antidiagonal n) = Finset.antidiagonal n |
AddAction.ext | Mathlib.Algebra.Group.Action.Defs | ∀ {G : Type u_9} {P : Type u_10} {inst : AddMonoid G} {x y : AddAction G P}, VAdd.vadd = VAdd.vadd → x = y |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.balRight.match_1.splitter._sparseCasesOn_4 | Batteries.Data.RBMap.WF | {motive : Batteries.RBColor → Sort u} →
(t : Batteries.RBColor) → motive Batteries.RBColor.black → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
Lean.getPPAnalyzeExplicitHoles | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.Options → Bool |
TopologicalSpace.Closeds.iInf_def | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_2} [inst : TopologicalSpace α] {ι : Sort u_4} (s : ι → TopologicalSpace.Closeds α),
⨅ i, s i = { carrier := ⋂ i, ↑(s i), isClosed' := ⋯ } |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.Ordered.append.match_1_15 | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} {cmp : α → α → Ordering} (a : Batteries.RBNode α) (x : α) (b : Batteries.RBNode α)
(motive : Batteries.RBNode.Ordered cmp (Batteries.RBNode.node Batteries.RBColor.black a x b) → Prop)
(hl : Batteries.RBNode.Ordered cmp (Batteries.RBNode.node Batteries.RBColor.black a x b)),
(∀ (ax : Batteries.RBNode.All (fun x_1 => Batteries.RBNode.cmpLT cmp x_1 x) a)
(xb : Batteries.RBNode.All (fun x_1 => Batteries.RBNode.cmpLT cmp x x_1) b) (ha : Batteries.RBNode.Ordered cmp a)
(hb : Batteries.RBNode.Ordered cmp b), motive ⋯) →
motive hl |
_private.Batteries.Data.RBMap.Alter.0.Batteries.RBNode.Path.Ordered.fill.match_1_1 | Batteries.Data.RBMap.Alter | ∀ {α : Type u_1} (motive : Batteries.RBNode.Path α → Batteries.RBNode α → Prop) (x : Batteries.RBNode.Path α)
(x_1 : Batteries.RBNode α),
(∀ (x : Batteries.RBNode α), motive Batteries.RBNode.Path.root x) →
(∀ (c : Batteries.RBColor) (parent : Batteries.RBNode.Path α) (v : α) (r x : Batteries.RBNode α),
motive (Batteries.RBNode.Path.left c parent v r) x) →
(∀ (c : Batteries.RBColor) (l : Batteries.RBNode α) (v : α) (parent : Batteries.RBNode.Path α)
(x : Batteries.RBNode α), motive (Batteries.RBNode.Path.right c l v parent) x) →
motive x x_1 |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKeyD_diff_of_contains_eq_false_left._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) |
SimpleGraph.nonempty_hom_of_forall_finite_subgraph_hom | Mathlib.Combinatorics.SimpleGraph.Finsubgraph | ∀ {V : Type u} {W : Type v} {G : SimpleGraph V} {F : SimpleGraph W} [Finite W]
(h : (G' : G.Subgraph) → G'.verts.Finite → G'.coe →g F), Nonempty (G →g F) |
Tree.noConfusion | Mathlib.Data.Tree.Basic | {P : Sort u_1} →
{α : Type u} → {t : Tree α} → {α' : Type u} → {t' : Tree α'} → α = α' → t ≍ t' → Tree.noConfusionType P t t' |
Ideal.Quotient.divisionRing._proof_9 | Mathlib.RingTheory.Ideal.Quotient.Basic | ∀ {R : Type u_1} [inst : Ring R] (I : Ideal R) [inst_1 : I.IsTwoSided] [inst_2 : I.IsMaximal], 0⁻¹ = 0 |
WellFoundedRelation.isWellFounded | Mathlib.Order.RelClasses | ∀ {α : Type u} [h : WellFoundedRelation α], IsWellFounded α WellFoundedRelation.rel |
Float32.recOn | Init.Data.Float32 | {motive : Float32 → Sort u} → (t : Float32) → ((val : float32Spec.float) → motive { val := val }) → motive t |
_private.Mathlib.Topology.Semicontinuity.Hemicontinuity.0.upperHemicontinuousWithinAt_singleton_iff._simp_1_2 | Mathlib.Topology.Semicontinuity.Hemicontinuity | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l₁ : Filter α} {l₂ : Filter β},
Filter.Tendsto f l₁ l₂ = ∀ s ∈ l₂, ∀ᶠ (x : α) in l₁, f x ∈ s |
LinearIsometryEquiv.symm_apply_apply | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
[inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E] [inst_7 : Module R₂ E₂]
(e : E ≃ₛₗᵢ[σ₁₂] E₂) (x : E), e.symm (e x) = x |
Int.dvd_emod_sub_self | Init.Data.Int.DivMod.Lemmas | ∀ {x m : ℤ}, m ∣ x % m - x |
_private.Mathlib.Algebra.Homology.ShortComplex.ExactFunctor.0.CategoryTheory.Functor.preservesFiniteLimits_tfae.match_1_1 | Mathlib.Algebra.Homology.ShortComplex.ExactFunctor | ∀ {C : Type u_2} {D : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] [inst_2 : CategoryTheory.Abelian C]
[inst_3 : CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [inst_4 : F.Additive]
(motive :
(∀ (S : CategoryTheory.ShortComplex C), S.ShortExact → (S.map F).Exact ∧ CategoryTheory.Mono (F.map S.f)) →
(x : CategoryTheory.ShortComplex C) → x.Exact ∧ CategoryTheory.Mono x.f → Prop)
(x : ∀ (S : CategoryTheory.ShortComplex C), S.ShortExact → (S.map F).Exact ∧ CategoryTheory.Mono (F.map S.f))
(x_1 : CategoryTheory.ShortComplex C) (x_2 : x_1.Exact ∧ CategoryTheory.Mono x_1.f),
(∀ (hF : ∀ (S : CategoryTheory.ShortComplex C), S.ShortExact → (S.map F).Exact ∧ CategoryTheory.Mono (F.map S.f))
(S : CategoryTheory.ShortComplex C) (hS : S.Exact) (hf : CategoryTheory.Mono S.f), motive hF S ⋯) →
motive x x_1 x_2 |
isAddCyclic_of_card_nsmul_eq_zero_le | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : DecidableEq α] [inst_2 : Fintype α],
(∀ (n : ℕ), 0 < n → {a | n • a = 0}.card ≤ n) → IsAddCyclic α |
Lean.Grind.CommRing.Poly.mulM | Lean.Meta.Tactic.Grind.Arith.CommRing.SafePoly | Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Lean.Meta.Grind.Arith.CommRing.RingM Lean.Grind.CommRing.Poly |
InfTopHom.dual._proof_1 | Mathlib.Order.Hom.BoundedLattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Min α] [inst_1 : Top α] [inst_2 : Min β] [inst_3 : Top β],
Function.LeftInverse (fun f => { toInfHom := InfHom.dual.symm f.toSupHom, map_top' := ⋯ }) fun f =>
{ toSupHom := InfHom.dual f.toInfHom, map_bot' := ⋯ } |
Set.bounded_ge_inter_ge | Mathlib.Order.Bounded | ∀ {α : Type u_1} {s : Set α} [inst : LinearOrder α] (a : α),
Set.Bounded (fun x1 x2 => x1 ≥ x2) (s ∩ {b | b ≤ a}) ↔ Set.Bounded (fun x1 x2 => x1 ≥ x2) s |
DirectSum.IsInternal.collectedBasis_orthonormal | Mathlib.Analysis.InnerProductSpace.Subspace | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_4} [inst_3 : DecidableEq ι] {V : ι → Submodule 𝕜 E},
(OrthogonalFamily 𝕜 (fun i => ↥(V i)) fun i => (V i).subtypeₗᵢ) →
∀ (hV_sum : DirectSum.IsInternal fun i => V i) {α : ι → Type u_6}
{v_family : (i : ι) → Module.Basis (α i) 𝕜 ↥(V i)},
(∀ (i : ι), Orthonormal 𝕜 ⇑(v_family i)) → Orthonormal 𝕜 ⇑(hV_sum.collectedBasis v_family) |
CategoryTheory.CommShift₂Setup.hε | Mathlib.CategoryTheory.Shift.CommShiftTwo | ∀ {D : Type u_5} [inst : CategoryTheory.Category.{v_5, u_5} D] {M : Type u_6} [inst_1 : AddCommMonoid M]
[inst_2 : CategoryTheory.HasShift D M] (self : CategoryTheory.CommShift₂Setup D M) (m n : M),
self.ε m n = (self.z (0, n) (m, 0))⁻¹ * self.z (m, 0) (0, n) |
HasFPowerSeriesAt.has_fpower_series_iterate_dslope_fslope | Mathlib.Analysis.Analytic.IsolatedZeros | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {p : FormalMultilinearSeries 𝕜 𝕜 E} {f : 𝕜 → E} {z₀ : 𝕜} (n : ℕ),
HasFPowerSeriesAt f p z₀ →
HasFPowerSeriesAt ((Function.swap dslope z₀)^[n] f) (FormalMultilinearSeries.fslope^[n] p) z₀ |
ContinuousAlternatingMap.alternatizeUncurryFinCLM._proof_1 | Mathlib.Analysis.Normed.Module.Alternating.Uncurry.Fin | ∀ (𝕜 : Type u_3) (E : Type u_2) (F : Type u_1) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ}
(f : E →L[𝕜] E [⋀^Fin n]→L[𝕜] F) (v : Fin (n + 1) → E),
‖(ContinuousAlternatingMap.alternatizeUncurryFinCLM.aux✝ f) v‖ ≤ ∑ i, ‖f‖ * ∏ i, ‖v i‖ |
Equiv.Perm.OnCycleFactors.odd_of_centralizer_le_alternatingGroup | Mathlib.GroupTheory.SpecificGroups.Alternating.Centralizer | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {g : Equiv.Perm α},
Subgroup.centralizer {g} ≤ alternatingGroup α → ∀ i ∈ g.cycleType, Odd i |
Matroid.exists_isBasis_union_inter_isBasis._auto_3 | Mathlib.Combinatorics.Matroid.Basic | Lean.Syntax |
_private.Mathlib.Logic.Equiv.Fin.Rotate.0.Fin.snoc_eq_cons_rotate._simp_1_1 | Mathlib.Logic.Equiv.Fin.Rotate | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) |
Matrix.PosDef.fromBlocks₂₂ | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {m : Type u_1} {n : Type u_2} {R' : Type u_4} [inst : CommRing R'] [inst_1 : PartialOrder R'] [inst_2 : StarRing R']
[inst_3 : Fintype n] [StarOrderedRing R'] [Finite m] [inst_6 : DecidableEq n] (A : Matrix m m R') (B : Matrix m n R')
{D : Matrix n n R'},
D.PosDef →
∀ [Invertible D], (Matrix.fromBlocks A B B.conjTranspose D).PosSemidef ↔ (A - B * D⁻¹ * B.conjTranspose).PosSemidef |
Real.arcosh_lt_arcosh | Mathlib.Analysis.SpecialFunctions.Arcosh | ∀ {x y : ℝ}, 0 < x → 0 < y → (Real.arcosh x < Real.arcosh y ↔ x < y) |
CategoryTheory.ComposableArrows.IsComplex.mk | Mathlib.Algebra.Homology.ExactSequence | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{n : ℕ} {S : CategoryTheory.ComposableArrows C n},
(∀ (i : ℕ) (hi : autoParam (i + 2 ≤ n) CategoryTheory.ComposableArrows.IsComplex._auto_1),
CategoryTheory.CategoryStruct.comp (S.map' i (i + 1) ⋯ ⋯) (S.map' (i + 1) (i + 2) ⋯ hi) = 0) →
S.IsComplex |
_private.Lean.Elab.Tactic.Do.ProofMode.Cases.0.Lean.Elab.Tactic.Do.ProofMode.mCasesExists.match_3 | Lean.Elab.Tactic.Do.ProofMode.Cases | (motive : Lean.Name × Lean.Syntax → Sort u_1) →
(__discr : Lean.Name × Lean.Syntax) → ((name : Lean.Name) → (ref : Lean.Syntax) → motive (name, ref)) → motive __discr |
ContDiffAt.csin | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {x : E} {n : WithTop ℕ∞},
ContDiffAt ℂ n f x → ContDiffAt ℂ n (fun x => Complex.sin (f x)) x |
Std.TreeMap.getElem?_eq_some_iff_exists_compare_eq_eq_and_mem_toList | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α} {v : β},
t[k]? = some v ↔ ∃ k', cmp k k' = Ordering.eq ∧ (k', v) ∈ t.toList |
enorm_add_le | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_8} [inst : TopologicalSpace E] [inst_1 : ESeminormedAddMonoid E] (a b : E), ‖a + b‖ₑ ≤ ‖a‖ₑ + ‖b‖ₑ |
Array.isEmpty_toList | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α}, xs.toList.isEmpty = xs.isEmpty |
Profinite.NobelingProof.spanCone_isLimit | Mathlib.Topology.Category.Profinite.Nobeling.Basic | {I : Type u} →
{C : Set (I → Bool)} →
[inst : (s : Finset I) → (i : I) → Decidable (i ∈ s)] →
(hC : IsCompact C) → CategoryTheory.Limits.IsLimit (Profinite.NobelingProof.spanCone hC) |
_private.Lean.Meta.DiscrTree.Basic.0.Lean.Meta.DiscrTree.keysAsPattern.mkApp | Lean.Meta.DiscrTree.Basic | Lean.MessageData → Array Lean.MessageData → Bool → Lean.CoreM Lean.MessageData |
LieAlgebra.SemiDirectSum.smul_eq_mk | Mathlib.Algebra.Lie.SemiDirect | ∀ {R : Type u_1} [inst : CommRing R] {K : Type u_2} [inst_1 : LieRing K] [inst_2 : LieAlgebra R K] {L : Type u_3}
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] (ψ : L →ₗ⁅R⁆ LieDerivation R K K) (t : R) (x : K ⋊⁅ψ⁆ L),
t • x = { left := t • x.left, right := t • x.right } |
AddUnits.instCoeHead | Mathlib.Algebra.Group.Units.Defs | {α : Type u} → [inst : AddMonoid α] → CoeHead (AddUnits α) α |
_private.Init.Data.Nat.Lemmas.0.Nat.mul_add_mod.match_1_1 | Init.Data.Nat.Lemmas | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (x : ℕ), motive x.succ) → motive x |
CategoryTheory.Limits.ChosenPullback₃.p₁₂_p_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X₁ X₂ X₃ S : C} {f₁ : X₁ ⟶ S} {f₂ : X₂ ⟶ S} {f₃ : X₃ ⟶ S}
{h₁₂ : CategoryTheory.Limits.ChosenPullback f₁ f₂} {h₂₃ : CategoryTheory.Limits.ChosenPullback f₂ f₃}
{h₁₃ : CategoryTheory.Limits.ChosenPullback f₁ f₃} (h : CategoryTheory.Limits.ChosenPullback₃ h₁₂ h₂₃ h₁₃) {Z : C}
(h_1 : S ⟶ Z),
CategoryTheory.CategoryStruct.comp h.p₁₂ (CategoryTheory.CategoryStruct.comp h₁₂.p h_1) =
CategoryTheory.CategoryStruct.comp h.p h_1 |
NumberField.Units.dirichletUnitTheorem.map_logEmbedding_sup_torsion | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (s : AddSubgroup (Additive (NumberField.RingOfIntegers K)ˣ)),
AddSubgroup.map (NumberField.Units.logEmbedding K) (s ⊔ Subgroup.toAddSubgroup (NumberField.Units.torsion K)) =
AddSubgroup.map (NumberField.Units.logEmbedding K) s |
FintypeCat.homMk_eq_comp_iff | Mathlib.CategoryTheory.FintypeCat | ∀ {X Y Z : FintypeCat} (f : X.carrier → Y.carrier) (g : Y.carrier → Z.carrier) (h : X.carrier → Z.carrier),
FintypeCat.homMk h = CategoryTheory.CategoryStruct.comp (FintypeCat.homMk f) (FintypeCat.homMk g) ↔ h = g ∘ f |
_private.Mathlib.Order.WithBot.0.WithBot.ofDual_le_iff._simp_1_1 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LE α] {a : αᵒᵈ} {b : α}, (OrderDual.toDual b ≤ a) = (OrderDual.ofDual a ≤ b) |
PFunctor.Approx.CofixA.recOn | Mathlib.Data.PFunctor.Univariate.M | {F : PFunctor.{uA, uB}} →
{motive : (a : ℕ) → PFunctor.Approx.CofixA F a → Sort u} →
{a : ℕ} →
(t : PFunctor.Approx.CofixA F a) →
motive 0 PFunctor.Approx.CofixA.continue →
({n : ℕ} →
(a : F.A) →
(a_1 : F.B a → PFunctor.Approx.CofixA F n) →
((a : F.B a) → motive n (a_1 a)) → motive n.succ (PFunctor.Approx.CofixA.intro a a_1)) →
motive a t |
Std.DTreeMap.Internal.Impl.SizedBalancedTree.toBalancedTree | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
{lb ub : ℕ} → Std.DTreeMap.Internal.Impl.SizedBalancedTree α β lb ub → Std.DTreeMap.Internal.Impl.BalancedTree α β |
_private.Lean.Server.Watchdog.0.Lean.Server.Watchdog.forwardMessages | Lean.Server.Watchdog | Lean.Server.Watchdog.FileWorker → Lean.Server.Watchdog.ServerM (Lean.Server.ServerTask Lean.Server.Watchdog.WorkerEvent) |
IntermediateField.sup_toSubalgebra_of_isAlgebraic_left | Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra | ∀ {K : Type u_3} {L : Type u_4} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
(E1 E2 : IntermediateField K L) [Algebra.IsAlgebraic K ↥E1],
(E1 ⊔ E2).toSubalgebra = E1.toSubalgebra ⊔ E2.toSubalgebra |
Rat.commRing._proof_4 | Mathlib.Algebra.Ring.Rat | ∀ (n : ℕ), ↑(Int.negSucc n) = -↑(n + 1) |
derivWithin_pow | Mathlib.Analysis.Calculus.Deriv.Pow | ∀ {𝕜 : Type u_1} {𝔸 : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedCommRing 𝔸]
[inst_2 : NormedAlgebra 𝕜 𝔸] {f : 𝕜 → 𝔸} {x : 𝕜} {s : Set 𝕜},
DifferentiableWithinAt 𝕜 f s x → ∀ (n : ℕ), derivWithin (f ^ n) s x = ↑n * f x ^ (n - 1) * derivWithin f s x |
Char.card_pow_card | Mathlib.NumberTheory.GaussSum | ∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] {F' : Type u_2} [inst_2 : Field F'] [inst_3 : Fintype F']
{χ : MulChar F F'},
χ ≠ 1 →
χ.IsQuadratic →
ringChar F' ≠ ringChar F →
ringChar F' ≠ 2 → (χ (-1) * ↑(Fintype.card F)) ^ (Fintype.card F' / 2) = χ ↑(Fintype.card F') |
BitVec.getElem_neg | Init.Data.BitVec.Bitblast | ∀ {w i : ℕ} {x : BitVec w} (h : i < w), (-x)[i] = (x[i] ^^ decide (∃ j < i, x.getLsbD j = true)) |
Lean.Elab.addPreDefInfo | Lean.Elab.PreDefinition.Basic | Lean.Elab.PreDefinition → Lean.Elab.TermElabM Unit |
HahnSeries.map.congr_simp | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_3} {S : Type u_4} [inst : PartialOrder Γ] [inst_1 : Zero R] [inst_2 : Zero S]
(x x_1 : HahnSeries Γ R),
x = x_1 →
∀ {F : Type u_5} [inst_3 : FunLike F R S] [inst_4 : ZeroHomClass F R S] (f f_1 : F), f = f_1 → x.map f = x_1.map f_1 |
_private.Mathlib.Probability.Independence.Integration.0.ProbabilityTheory.lintegral_mul_indicator_eq_lintegral_mul_lintegral_indicator._simp_1_2 | Mathlib.Probability.Independence.Integration | ∀ {α : Type u_1} {m : MeasurableSpace α}, MeasurableSet Set.univ = True |
_private.Mathlib.CategoryTheory.Monoidal.Cartesian.Basic.0.CategoryTheory.CartesianMonoidalCategory.associator_hom_snd_fst._simp_1_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C) {Z : C}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj X Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator X Y (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)).hom
h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.MonoidalCategoryStruct.rightUnitor Y).hom) h |
Int32.ofNat_add | Init.Data.SInt.Lemmas | ∀ (a b : ℕ), Int32.ofNat (a + b) = Int32.ofNat a + Int32.ofNat b |
Sat.Literal.noConfusion | Mathlib.Tactic.Sat.FromLRAT | {P : Sort u} → {t t' : Sat.Literal} → t = t' → Sat.Literal.noConfusionType P t t' |
MonoidWithZeroHom.instGroupWithZeroSubtypeMemSubmonoidMrange | Mathlib.Algebra.GroupWithZero.Submonoid.Instances | {G : Type u_1} →
{H : Type u_2} →
[inst : GroupWithZero G] → [inst_1 : GroupWithZero H] → (f : G →*₀ H) → GroupWithZero ↥(MonoidHom.mrange f) |
Lean.Elab.Tactic.evalExposeNames | Lean.Elab.Tactic.ExposeNames | Lean.Elab.Tactic.Tactic |
Lean.TagDeclarationExtension | Lean.EnvExtension | Type |
openSegment_subset_segment | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : SMul 𝕜 E] (x y : E), openSegment 𝕜 x y ⊆ segment 𝕜 x y |
Lean.Compiler.LCNF.Phase.toNat | Lean.Compiler.LCNF.PassManager | Lean.Compiler.LCNF.Phase → ℕ |
Units.isOpenEmbedding_val | Mathlib.Analysis.Normed.Ring.Units | ∀ {R : Type u_1} [inst : NormedRing R] [HasSummableGeomSeries R], Topology.IsOpenEmbedding Units.val |
AlgebraicGeometry.Scheme.instIsOverMapStalkSpecializesCommRingCatPresheaf | Mathlib.AlgebraicGeometry.Stalk | ∀ {X : AlgebraicGeometry.Scheme} {x y : ↥X} (h : x ⤳ y),
AlgebraicGeometry.Scheme.Hom.IsOver (AlgebraicGeometry.Spec.map (X.presheaf.stalkSpecializes h)) X |
Algebra.Extension.infinitesimal.eq_1 | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : Algebra.Extension R S),
P.infinitesimal =
{ Ring := P.Ring ⧸ P.ker ^ 2, commRing := Ideal.Quotient.commRing (P.ker ^ 2),
algebra₁ := Ideal.instAlgebraQuotient R (P.ker ^ 2), algebra₂ := Ideal.Algebra.kerSquareLift, isScalarTower := ⋯,
σ := ⇑(Ideal.Quotient.mk (P.ker ^ 2)) ∘ P.σ, algebraMap_σ := ⋯ } |
HSpaces._aux_Mathlib_Topology_Homotopy_HSpaces___unexpand_HSpace_hmul_1 | Mathlib.Topology.Homotopy.HSpaces | Lean.PrettyPrinter.Unexpander |
List.getRest._sunfold | Batteries.Data.List.Basic | {α : Type u_1} → [DecidableEq α] → List α → List α → Option (List α) |
PredOrder.pred | Mathlib.Order.SuccPred.Basic | {α : Type u_3} → {inst : Preorder α} → [self : PredOrder α] → α → α |
Stream'.Seq.mem_cons_of_mem | Mathlib.Data.Seq.Defs | ∀ {α : Type u} (y : α) {a : α} {s : Stream'.Seq α}, a ∈ s → a ∈ Stream'.Seq.cons y s |
_private.Mathlib.Analysis.FunctionalSpaces.SobolevInequality.0.«_aux_Mathlib_Analysis_FunctionalSpaces_SobolevInequality___macroRules__private_Mathlib_Analysis_FunctionalSpaces_SobolevInequality_0_term#__1» | Mathlib.Analysis.FunctionalSpaces.SobolevInequality | Lean.Macro |
_private.Mathlib.Probability.ProductMeasure.0.MeasureTheory.Measure.infinitePi_pi_of_countable._simp_1_5 | Mathlib.Probability.ProductMeasure | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [MeasureTheory.IsZeroOrProbabilityMeasure μ]
{s : Set α}, (μ s ≤ 1) = True |
_private.Mathlib.LinearAlgebra.PiTensorProduct.Basis.0.Basis.piTensorProduct_apply._simp_1_1 | Mathlib.LinearAlgebra.PiTensorProduct.Basis | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) = (f = g) |
Filter.Germ.liftPred_const | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {p : β → Prop} {x : β}, p x → Filter.Germ.LiftPred p ↑x |
SummationFilter.NeBot.ne_bot | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | ∀ {β : Type u_2} {L : SummationFilter β} [self : L.NeBot], L.filter.NeBot |
Set.Nonempty.right | Mathlib.Data.Set.Basic | ∀ {α : Type u} {s t : Set α}, (s ∩ t).Nonempty → t.Nonempty |
Filter.map₂_inf_subset_left | Mathlib.Order.Filter.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f₁ f₂ : Filter α} {g : Filter β},
Filter.map₂ m (f₁ ⊓ f₂) g ≤ Filter.map₂ m f₁ g ⊓ Filter.map₂ m f₂ g |
StandardEtalePair.lift.eq_1 | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : StandardEtalePair R) (x : S) (h : P.HasMap x),
P.lift x h =
Ideal.Quotient.liftₐ (Ideal.span {Polynomial.C P.f, Polynomial.X * Polynomial.C P.g - 1})
(Polynomial.aevalAeval x ↑⋯.unit⁻¹) ⋯ |
MeasureTheory.Filtration.piFinset | Mathlib.Probability.Process.Filtration | {ι : Type u_4} →
{X : ι → Type u_5} → [inst : (i : ι) → MeasurableSpace (X i)] → MeasureTheory.Filtration (Finset ι) MeasurableSpace.pi |
CpltSepUniformSpace.coe_of | Mathlib.Topology.Category.UniformSpace | ∀ (X : Type u) [inst : UniformSpace X] [inst_1 : CompleteSpace X] [inst_2 : T0Space X], (CpltSepUniformSpace.of X).α = X |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.