name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Lean.Meta.HaveTelescope.0.Lean.Meta.simpHaveTelescopeAux.match_11 | Lean.Meta.HaveTelescope | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((n : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const n us)) → ((x : Lean.Expr) → motive x) → motive x |
Std.ExtDHashMap.get_insertMany_list_of_contains_eq_false | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{l : List ((a : α) × β a)} {k : α} (contains_eq_false : (List.map Sigma.fst l).contains k = false)
{h : k ∈ m.insertMany l}, (m.insertMany l).get k h = m.get k ⋯ |
Real.instAddRightCancelSemigroup | Mathlib.Data.Real.Basic | AddRightCancelSemigroup ℝ |
Ideal.exists_coeff_ne_zero_mem_comap_of_non_zero_divisor_root_mem | Mathlib.RingTheory.Ideal.GoingUp | ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_2} [inst_1 : CommRing S] {f : R →+* S} {I : Ideal S} {r : S},
(∀ {x : S}, x * r = 0 → x = 0) →
r ∈ I → ∀ {p : Polynomial R}, p ≠ 0 → Polynomial.eval₂ f r p = 0 → ∃ i, p.coeff i ≠ 0 ∧ p.coeff i ∈ Ideal.comap f I |
Lean.Elab.Tactic.Do.Context.mk.injEq | Lean.Elab.Tactic.Do.VCGen.Basic | ∀ (config : Lean.Elab.Tactic.Do.VCGen.Config) (specThms : Lean.Elab.Tactic.Do.SpecAttr.SpecTheorems)
(simpCtx : Lean.Meta.Simp.Context) (simprocs : Lean.Meta.Simp.SimprocsArray)
(jps : Lean.FVarIdMap Lean.Elab.Tactic.Do.JumpSiteInfo) (initialCtxSize : ℕ)
(config_1 : Lean.Elab.Tactic.Do.VCGen.Config) (specThms_1 : Lean.Elab.Tactic.Do.SpecAttr.SpecTheorems)
(simpCtx_1 : Lean.Meta.Simp.Context) (simprocs_1 : Lean.Meta.Simp.SimprocsArray)
(jps_1 : Lean.FVarIdMap Lean.Elab.Tactic.Do.JumpSiteInfo) (initialCtxSize_1 : ℕ),
({ config := config, specThms := specThms, simpCtx := simpCtx, simprocs := simprocs, jps := jps,
initialCtxSize := initialCtxSize } =
{ config := config_1, specThms := specThms_1, simpCtx := simpCtx_1, simprocs := simprocs_1, jps := jps_1,
initialCtxSize := initialCtxSize_1 }) =
(config = config_1 ∧
specThms = specThms_1 ∧
simpCtx = simpCtx_1 ∧ simprocs = simprocs_1 ∧ jps = jps_1 ∧ initialCtxSize = initialCtxSize_1) |
groupCohomology.d₀₁._proof_2 | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep k G) (r : k) (x : ↑A.1) (g : G),
(A.ρ g) (r • x) - r • x = ((RingHom.id k) r • fun g => (A.ρ g) x - x) g |
Fintype.univ_ofIsEmpty | Mathlib.Data.Fintype.OfMap | ∀ {α : Type u_1} [inst : IsEmpty α], Finset.univ = ∅ |
UInt8.shiftLeft_add_of_toNat_lt | Init.Data.UInt.Bitwise | ∀ {a b c : UInt8}, b.toNat + c.toNat < 8 → a <<< (b + c) = a <<< b <<< c |
_private.Init.Data.ByteArray.Bootstrap.0.List.toByteArray.match_1.splitter | Init.Data.ByteArray.Bootstrap | (motive : List UInt8 → ByteArray → Sort u_1) →
(x : List UInt8) →
(x_1 : ByteArray) →
((r : ByteArray) → motive [] r) →
((b : UInt8) → (bs : List UInt8) → (r : ByteArray) → motive (b :: bs) r) → motive x x_1 |
SimpleGraph.edgeDisjointTriangles_iff_mem_sym2_subsingleton | Mathlib.Combinatorics.SimpleGraph.Triangle.Basic | ∀ {α : Type u_1} {G : SimpleGraph α},
G.EdgeDisjointTriangles ↔ ∀ ⦃e : Sym2 α⦄, ¬e.IsDiag → {s | s ∈ G.cliqueSet 3 ∧ e ∈ s.sym2}.Subsingleton |
SimpleGraph.Walk.isSubwalk_concat._simp_1 | Mathlib.Combinatorics.SimpleGraph.Walks.Subwalks | ∀ {V : Type u_1} {G : SimpleGraph V} {u v w : V} (p : G.Walk u v) (h : G.Adj v w), p.IsSubwalk (p.concat h) = True |
_private.Lean.Data.Json.Printer.0.Lean.Json.CompressWorkItemQueue.popObjectFieldKey! | Lean.Data.Json.Printer | Lean.Json.CompressWorkItemQueue✝ → String × Lean.Json.CompressWorkItemQueue✝¹ |
CategoryTheory.NatTrans.naturality_app | Mathlib.CategoryTheory.Functor.Category | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E]
{F G : CategoryTheory.Functor C (CategoryTheory.Functor D E)} (T : F ⟶ G) (Z : D) {X Y : C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((F.map f).app Z) ((T.app Y).app Z) =
CategoryTheory.CategoryStruct.comp ((T.app X).app Z) ((G.map f).app Z) |
CategoryTheory.InjectiveResolution.instInjectiveXNatOfCocomplex | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.EnoughInjectives C] (Z : C) (n : ℕ),
CategoryTheory.Injective ((CategoryTheory.InjectiveResolution.ofCocomplex Z).X n) |
instNonAssocSemiringWithConvMatrix._proof_1 | Mathlib.LinearAlgebra.Matrix.WithConv | ∀ {m : Type u_1} {n : Type u_2} {α : Type u_3} [inst : NonAssocSemiring α], Nat.unaryCast 0 = 0 |
FiberBundle.prod_trivializationAt' | Mathlib.Topology.FiberBundle.Constructions | ∀ {B : Type u_1} [inst : TopologicalSpace B] (F₁ : Type u_2) [inst_1 : TopologicalSpace F₁] (E₁ : B → Type u_3)
[inst_2 : TopologicalSpace (Bundle.TotalSpace F₁ E₁)] (F₂ : Type u_4) [inst_3 : TopologicalSpace F₂]
(E₂ : B → Type u_5) [inst_4 : TopologicalSpace (Bundle.TotalSpace F₂ E₂)] [inst_5 : (x : B) → Zero (E₁ x)]
[inst_6 : (x : B) → Zero (E₂ x)] [inst_7 : (x : B) → TopologicalSpace (E₁ x)]
[inst_8 : (x : B) → TopologicalSpace (E₂ x)] [inst_9 : FiberBundle F₁ E₁] [inst_10 : FiberBundle F₂ E₂] (b : B),
FiberBundle.trivializationAt' b = (trivializationAt F₁ E₁ b).prod (trivializationAt F₂ E₂ b) |
Matroid.contract_spanning_iff | Mathlib.Combinatorics.Matroid.Minor.Contract | ∀ {α : Type u_1} {M : Matroid α} {X C : Set α},
autoParam (C ⊆ M.E) Matroid.contract_spanning_iff._auto_1 →
((M.contract C).Spanning X ↔ M.Spanning (X ∪ C) ∧ Disjoint X C) |
CategoryTheory.Functor.preservesProjectiveObjects_of_isEquivalence | Mathlib.CategoryTheory.Preadditive.Projective.Preserves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} [F.IsEquivalence], F.PreservesProjectiveObjects |
Valued.maximalIdeal._proof_2 | Mathlib.Topology.Algebra.Valued.ValuedField | ∀ (K : Type u_1) [inst : Field K] {Γ₀ : outParam (Type u_2)} [inst_1 : LinearOrderedCommGroupWithZero Γ₀]
[vK : Valued K Γ₀], IsLocalRing ↥(Valued.integer K) |
Lean.Parser.Command.open._regBuiltin.Lean.Parser.Command.openOnly.formatter_21 | Lean.Parser.Command | IO Unit |
Topology.IsInducing.r1Space | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [R1Space X] [inst_2 : TopologicalSpace Y] {f : Y → X},
Topology.IsInducing f → R1Space Y |
omegaLimit_def | Mathlib.Dynamics.OmegaLimit | ∀ {τ : Type u_1} {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace β] (f : Filter τ) (ϕ : τ → α → β) (s : Set α),
omegaLimit f ϕ s = ⋂ u ∈ f, closure (Set.image2 ϕ u s) |
Submonoid.comap_iInf | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] {ι : Sort u_5} (f : F) (s : ι → Submonoid N),
Submonoid.comap f (iInf s) = ⨅ i, Submonoid.comap f (s i) |
_private.Mathlib.Order.Filter.Ultrafilter.Basic.0.Filter.tendsto_iff_ultrafilter._simp_1_1 | Mathlib.Order.Filter.Ultrafilter.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l₁ : Filter α} {l₂ : Filter β},
Filter.Tendsto f l₁ l₂ = (l₁ ≤ Filter.comap f l₂) |
Real.Angle.two_zsmul_toReal_eq_two_mul | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ : Real.Angle}, (2 • θ).toReal = 2 * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-Real.pi / 2) (Real.pi / 2) |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toArray_rco_eq_singleton_iff._proof_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {k m n : ℕ}, m < n → ¬(m = k ∧ n ≤ m + 1 ↔ n = m + 1 ∧ m = k) → False |
MeasureTheory.ae_le_toMeasurable | Mathlib.MeasureTheory.Measure.MeasureSpaceDef | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α},
s ≤ᵐ[μ] MeasureTheory.toMeasurable μ s |
_private.Mathlib.Probability.Decision.Risk.Basic.0.ProbabilityTheory.avgRisk_le_mul'._simp_1_1 | Mathlib.Probability.Decision.Risk.Basic | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c |
Set.indicator_eq_zero._simp_1 | Mathlib.Algebra.Notation.Indicator | ∀ {α : Type u_1} {M : Type u_3} [inst : Zero M] {s : Set α} {f : α → M},
(s.indicator f = fun x => 0) = Disjoint (Function.support f) s |
Std.ExtTreeMap.isEmpty_iff._simp_1 | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [Std.TransCmp cmp],
(t.isEmpty = true) = (t = ∅) |
IsOfFinOrder.isUnit | Mathlib.GroupTheory.OrderOfElement | ∀ {M : Type u_6} [inst : Monoid M] {x : M}, IsOfFinOrder x → IsUnit x |
Std.Rcc.ctorIdx | Init.Data.Range.Polymorphic.PRange | {α : Type u} → Std.Rcc α → ℕ |
Mathlib.Tactic.TermCongr.unexpandCHole | Mathlib.Tactic.TermCongr | Lean.PrettyPrinter.Unexpander |
instIsAtomisticSubmodule | Mathlib.LinearAlgebra.Basis.VectorSpace | ∀ {K : Type u_3} {V : Type u_4} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V],
IsAtomistic (Submodule K V) |
AddOpposite.instNonUnitalSemiring | Mathlib.Algebra.Ring.Opposite | {R : Type u_1} → [NonUnitalSemiring R] → NonUnitalSemiring Rᵃᵒᵖ |
_private.Init.Data.UInt.Lemmas.0.UInt8.toUSize_le._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {a b : USize}, (a ≤ b) = (a.toNat ≤ b.toNat) |
_private.Init.Data.String.Slice.0.String.Slice.SplitInclusiveIterator.toOption.match_1 | Init.Data.String.Slice | {ρ : Type} →
{σ : String.Slice → Type} →
{pat : ρ} →
[inst : String.Slice.Pattern.ToForwardSearcher pat σ] →
{s : String.Slice} →
(motive : String.Slice.SplitInclusiveIterator pat s → Sort u_1) →
(x : String.Slice.SplitInclusiveIterator pat s) →
((currPos : s.Pos) →
(s_1 : Std.Iter (String.Slice.Pattern.SearchStep s)) →
motive (String.Slice.SplitInclusiveIterator.operating currPos s_1)) →
(Unit → motive String.Slice.SplitInclusiveIterator.atEnd) → motive x |
Equiv.sigmaProdDistrib._proof_4 | Mathlib.Logic.Equiv.Prod | ∀ {ι : Type u_3} (α : ι → Type u_1) (β : Type u_2),
Function.RightInverse (fun p => (⟨p.fst, p.snd.1⟩, p.snd.2)) fun p => ⟨p.1.fst, (p.1.snd, p.2)⟩ |
Lean.StructureResolutionOrderConflict.ctorIdx | Lean.Structure | Lean.StructureResolutionOrderConflict → ℕ |
SimpleGraph.cliqueSet_zero | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} (G : SimpleGraph α), G.cliqueSet 0 = {∅} |
CategoryTheory.PreZeroHypercover.I₀ | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → {S : C} → CategoryTheory.PreZeroHypercover S → Type w |
Cardinal.IsStrongLimit.isSuccLimit | Mathlib.SetTheory.Cardinal.Order | ∀ {c : Cardinal.{u_1}}, c.IsStrongLimit → Order.IsSuccLimit c |
TrivSqZeroExt.instL1SeminormedRing._proof_16 | Mathlib.Analysis.Normed.Algebra.TrivSqZeroExt | ∀ {R : Type u_1} {M : Type u_2} [inst : SeminormedRing R] [inst_1 : SeminormedAddCommGroup M] (n : ℕ)
(a : TrivSqZeroExt R M), SubNegMonoid.zsmul (↑n.succ) a = SubNegMonoid.zsmul (↑n) a + a |
CategoryTheory.GrpObj.lift_comp_inv_left | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{A B : C} [inst_2 : CategoryTheory.GrpObj B] (f : A ⟶ B),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CartesianMonoidalCategory.lift (CategoryTheory.CategoryStruct.comp f CategoryTheory.GrpObj.inv) f)
CategoryTheory.MonObj.mul =
CategoryTheory.CategoryStruct.comp (CategoryTheory.SemiCartesianMonoidalCategory.toUnit A) CategoryTheory.MonObj.one |
instFaithfulSMulOfIsRightCancelMul | Mathlib.Algebra.Group.Action.Faithful | ∀ (R : Type u_4) [inst : Mul R] [IsRightCancelMul R], FaithfulSMul R R |
_private.Mathlib.Analysis.Complex.CauchyIntegral.0.Complex.analyticOnNhd_univ_iff_differentiable._simp_1_1 | Mathlib.Analysis.Complex.CauchyIntegral | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F}, Differentiable 𝕜 f = DifferentiableOn 𝕜 f Set.univ |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_356 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α) (h_3 : ¬[g a, g (g a)].Nodup) (w_1 : α)
(h_5 : 2 ≤ List.count w_1 [g a, g (g a)]),
(List.findIdxs (fun x => decide (x = w_1))
[g a,
g
(g
a)])[List.findIdxNth (fun x => decide (x = w_1)) [g a, g (g a)]
(List.idxOfNth w_1 [g a, g (g a)] {g (g a)}.card)] <
[g a, g (g a)].length |
PosSMulStrictMono.nnrat_of_rat | Mathlib.Algebra.Order.Module.Rat | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : MulAction ℚ≥0 α] [inst_2 : MulAction ℚ α] [IsScalarTower ℚ≥0 ℚ α]
[PosSMulStrictMono ℚ α], PosSMulStrictMono ℚ≥0 α |
List.subperm_of_subset | Batteries.Data.List.Perm | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Nodup → l₁ ⊆ l₂ → l₁.Subperm l₂ |
CategoryTheory.Limits.Cocone.equivStructuredArrow | Mathlib.CategoryTheory.Limits.ConeCategory | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
(F : CategoryTheory.Functor J C) →
CategoryTheory.Limits.Cocone F ≌ CategoryTheory.StructuredArrow F (CategoryTheory.Functor.const J) |
_private.Lean.Compiler.LCNF.Simp.Main.0.Lean.Compiler.LCNF.Simp.specializePartialApp.match_1 | Lean.Compiler.LCNF.Simp.Main | (motive :
Option
(Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure ×
Subarray (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) →
Sort u_1) →
(x :
Option
(Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure ×
Subarray (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure))) →
(Unit → motive none) →
((arg : Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) →
(s' : Subarray (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) → motive (some (arg, s'))) →
motive x |
Multiset.rel_map | Mathlib.Data.Multiset.MapFold | ∀ {α : Type u_1} {β : Type v} {γ : Type u_2} {δ : Type u_3} {p : γ → δ → Prop} {s : Multiset α} {t : Multiset β}
{f : α → γ} {g : β → δ},
Multiset.Rel p (Multiset.map f s) (Multiset.map g t) ↔ Multiset.Rel (fun a b => p (f a) (g b)) s t |
Finset.lt_eq_subset | Mathlib.Data.Finset.Defs | ∀ {α : Type u_1}, (fun x1 x2 => x1 < x2) = fun x1 x2 => x1 ⊂ x2 |
CategoryTheory.Prod.sectL_obj | Mathlib.CategoryTheory.Products.Basic | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(Z : D) (X : C), (CategoryTheory.Prod.sectL C Z).obj X = (X, Z) |
_private.Mathlib.Combinatorics.SimpleGraph.Hall.0.SimpleGraph.exists_bijective_of_forall_ncard_le._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Hall | ∀ {α : Type u_1} (s : Finset α), s.card = (↑s).ncard |
SSet.Truncated.HomotopyCategory.isoTerminal._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.HoFunctorMonoidal | (SimplexCategory.mk 1).len ≤ 2 |
IntermediateField.adjoin_toSubfield | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ (F : Type u_1) [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] (S : Set E),
(IntermediateField.adjoin F S).toSubfield = Subfield.closure (Set.range ⇑(algebraMap F E) ∪ S) |
CliffordAlgebra.instAlgebra' | Mathlib.LinearAlgebra.CliffordAlgebra.Basic | {R : Type u_3} →
{A : Type u_4} →
{M : Type u_5} →
[inst : CommSemiring R] →
[inst_1 : AddCommGroup M] →
[inst_2 : CommRing A] →
[inst_3 : Algebra R A] →
[inst_4 : Module R M] →
[inst_5 : Module A M] → (Q : QuadraticForm A M) → [IsScalarTower R A M] → Algebra R (CliffordAlgebra Q) |
_private.Mathlib.Data.Set.Prod.0.Set.disjoint_prod._simp_1_3 | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) |
NumberField.mixedEmbedding.fundamentalCone.volume_frontier_normLeOne | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
MeasureTheory.volume (frontier (NumberField.mixedEmbedding.fundamentalCone.normLeOne K)) = 0 |
CategoryTheory.Limits.binaryCofanZeroRight | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[CategoryTheory.Limits.HasZeroMorphisms C] → (X : C) → CategoryTheory.Limits.BinaryCofan X 0 |
UniqueMDiffWithinAt.bundle_preimage' | Mathlib.Geometry.Manifold.MFDeriv.UniqueDifferential | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {s : Set M} {F : Type u_9} [inst_6 : NormedAddCommGroup F]
[inst_7 : NormedSpace 𝕜 F] (Z : M → Type u_10) [inst_8 : TopologicalSpace (Bundle.TotalSpace F Z)]
[inst_9 : (b : M) → TopologicalSpace (Z b)] [inst_10 : FiberBundle F Z] {b : M},
UniqueMDiffWithinAt I s b →
∀ (x : Z b), UniqueMDiffWithinAt (I.prod (modelWithCornersSelf 𝕜 F)) (Bundle.TotalSpace.proj ⁻¹' s) ⟨b, x⟩ |
Lean.Elab.Term.LevelMVarErrorInfo.logError | Lean.Elab.Term.TermElabM | Lean.Elab.Term.LevelMVarErrorInfo → Lean.Elab.TermElabM Unit |
Lean.Lsp.InitializationOptions.noConfusion | Lean.Data.Lsp.InitShutdown | {P : Sort u} → {t t' : Lean.Lsp.InitializationOptions} → t = t' → Lean.Lsp.InitializationOptions.noConfusionType P t t' |
_private.Mathlib.AlgebraicGeometry.StructureSheaf.0.AlgebraicGeometry.StructureSheaf.toBasicOpenₗ._proof_3 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ (R M : Type u_1) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (f : R),
IsScalarTower R R ((AlgebraicGeometry.structureSheafInType R M).obj.obj (Opposite.op (PrimeSpectrum.basicOpen f))) |
CategoryTheory.WithTerminal.widePullbackShapeEquiv._proof_8 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {J : Type u_1} (X : CategoryTheory.WithTerminal (CategoryTheory.Discrete J)),
(CategoryTheory.WithTerminal.widePullbackShapeEquivMap✝
(CategoryTheory.WithTerminal.widePullbackShapeEquivObj✝.symm X)
(CategoryTheory.WithTerminal.widePullbackShapeEquivObj✝¹.symm X)).symm
(CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) (CategoryTheory.eqToHom ⋯))) =
CategoryTheory.CategoryStruct.id (CategoryTheory.WithTerminal.widePullbackShapeEquivObj✝².symm X) |
_private.Init.Data.List.Pairwise.0.List.pairwise_flatten._simp_1_1 | Init.Data.List.Pairwise | ∀ {α : Type u_1} {R : α → α → Prop} {l₁ l₂ : List α},
List.Pairwise R (l₁ ++ l₂) = (List.Pairwise R l₁ ∧ List.Pairwise R l₂ ∧ ∀ a ∈ l₁, ∀ b ∈ l₂, R a b) |
Mathlib.Meta.FunProp.LambdaTheoremArgs.const.elim | Mathlib.Tactic.FunProp.Theorems | {motive : Mathlib.Meta.FunProp.LambdaTheoremArgs → Sort u} →
(t : Mathlib.Meta.FunProp.LambdaTheoremArgs) →
t.ctorIdx = 1 → motive Mathlib.Meta.FunProp.LambdaTheoremArgs.const → motive t |
MulAction.noConfusion | Mathlib.Algebra.Group.Action.Defs | {P : Sort u} →
{α : Type u_9} →
{β : Type u_10} →
{inst : Monoid α} →
{t : MulAction α β} →
{α' : Type u_9} →
{β' : Type u_10} →
{inst' : Monoid α'} →
{t' : MulAction α' β'} → α = α' → β = β' → inst ≍ inst' → t ≍ t' → MulAction.noConfusionType P t t' |
MonovaryOn.pow_right | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : CommGroup β] [inst_2 : LinearOrder β]
[IsOrderedMonoid β] {s : Set ι} {f : ι → α} {g : ι → β}, MonovaryOn f g s → ∀ (n : ℕ), MonovaryOn f (g ^ n) s |
Int.gcd_pos_of_ne_zero_left | Init.Data.Int.Gcd | ∀ {a : ℤ} (b : ℤ), a ≠ 0 → 0 < a.gcd b |
Lean.Elab.InlayHintKind.ctorElim | Lean.Elab.InfoTree.InlayHints | {motive : Lean.Elab.InlayHintKind → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Elab.InlayHintKind) → ctorIdx = t.ctorIdx → Lean.Elab.InlayHintKind.ctorElimType ctorIdx → motive t |
Std.HashMap.Raw.Equiv.diff_left | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ m₃ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → m₃.WF → m₁.Equiv m₂ → (m₁ \ m₃).Equiv (m₂ \ m₃) |
Lean.Parser.AliasValue._sizeOf_inst | Lean.Parser.Extension | (α : Type) → [SizeOf α] → SizeOf (Lean.Parser.AliasValue α) |
CategoryTheory.SemiadditiveOfBinaryBiproducts.isUnital_leftAdd | Mathlib.CategoryTheory.Preadditive.OfBiproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] (X Y : C),
EckmannHilton.IsUnital (fun x1 x2 => CategoryTheory.SemiadditiveOfBinaryBiproducts.leftAdd X Y x1 x2) 0 |
Fin.pos_iff_ne_zero | Init.Data.Fin.Lemmas | ∀ {n : ℕ} [inst : NeZero n] {a : Fin n}, 0 < a ↔ a ≠ 0 |
IsLocalization.mk'_spec | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} (S : Type u_2) [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : IsLocalization M S] (x : R) (y : ↥M),
IsLocalization.mk' S x y * (algebraMap R S) ↑y = (algebraMap R S) x |
CategoryTheory.Over.associator_inv_left_fst_snd_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {X : C}
(R S T : CategoryTheory.Over X) {Z : C} (h : S.left ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator R S T).inv.left
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.fst
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst R.hom S.hom) R.hom) T.hom)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.snd R.hom S.hom) h)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.snd R.hom (CategoryTheory.MonoidalCategoryStruct.tensorObj S T).hom)
(CategoryTheory.Limits.pullback.fst S.hom T.hom))
h |
Set.Ico.coe_eq_zero | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R] [inst_3 : Nontrivial R]
{x : ↑(Set.Ico 0 1)}, ↑x = 0 ↔ x = 0 |
_private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxc.Iterator.instIteratorAccess.match_1.splitter | Init.Data.Range.Polymorphic.RangeIterator | {α : Type u_1} →
(motive : Option α → Sort u_2) → (x : Option α) → (Unit → motive none) → ((next : α) → motive (some next)) → motive x |
_private.Lean.Shell.0.Lean.ShellOptions.process.throwExpectedNumeric | Lean.Shell | String → EIO UInt32 PUnit.{1} |
Set.iUnion_iInter_of_antitone | Mathlib.Data.Set.Finite.Lattice | ∀ {ι : Type u_1} {ι' : Type u_2} {α : Type u_3} [Finite ι] [inst : Preorder ι'] [IsCodirectedOrder ι'] [Nonempty ι']
{s : ι → ι' → Set α}, (∀ (i : ι), Antitone (s i)) → ⋃ j, ⋂ i, s i j = ⋂ i, ⋃ j, s i j |
Lean.Lsp.CodeActionTriggerKind.casesOn | Lean.Data.Lsp.CodeActions | {motive : Lean.Lsp.CodeActionTriggerKind → Sort u} →
(t : Lean.Lsp.CodeActionTriggerKind) →
motive Lean.Lsp.CodeActionTriggerKind.invoked → motive Lean.Lsp.CodeActionTriggerKind.automatic → motive t |
Int16.ofIntTruncate_bitVecToInt | Init.Data.SInt.Lemmas | ∀ (n : BitVec 16), Int16.ofIntTruncate n.toInt = Int16.ofBitVec n |
DirectSum.ring | Mathlib.Algebra.DirectSum.Ring | {ι : Type u_1} →
[DecidableEq ι] →
(A : ι → Type u_2) →
[inst : (i : ι) → AddCommGroup (A i)] →
[inst_1 : AddMonoid ι] → [DirectSum.GRing A] → Ring (DirectSum ι fun i => A i) |
HolderWith.holderWith_zero_of_bounded | Mathlib.Topology.MetricSpace.Holder | ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y] {r : NNReal} {f : X → Y}
{C D : NNReal}, (∀ (x y : X), edist x y ≤ ↑D) → HolderWith C r f → HolderWith (C * D ^ ↑r) 0 f |
Nat.strongSubRecursion.match_1 | Mathlib.Data.Nat.Init | (motive : ℕ → ℕ → Sort u_1) → (x x_1 : ℕ) → ((n m : ℕ) → motive n m) → motive x x_1 |
Std.DTreeMap.contains_filterMap | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} {γ : α → Type w} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp] {f : (a : α) → β a → Option (γ a)} {k : α},
(Std.DTreeMap.filterMap f t).contains k = Option.any (fun x => (f k x).isSome) (t.get? k) |
ZMod.instIsDomainOfNatNat | Mathlib.Data.ZMod.Basic | IsDomain (ZMod 0) |
_private.Lean.Data.Json.Printer.0.Lean.Json.CompressWorkItemQueue.rec | Lean.Data.Json.Printer | {motive : Lean.Json.CompressWorkItemQueue✝ → Sort u} →
((kinds : Array Lean.Json.CompressWorkItemKind✝) →
(values : Array Lean.Json) →
(objectFieldKeys : Array String) →
motive { kinds := kinds, values := values, objectFieldKeys := objectFieldKeys }) →
(t : Lean.Json.CompressWorkItemQueue✝¹) → motive t |
Setoid.instLE_mathlib | Mathlib.Data.Setoid.Basic | {α : Type u_1} → LE (Setoid α) |
IsModularLattice.recOn | Mathlib.Order.ModularLattice | {α : Type u_2} →
[inst : Lattice α] →
{motive : IsModularLattice α → Sort u} →
(t : IsModularLattice α) →
((sup_inf_le_assoc_of_le : ∀ {x : α} (y : α) {z : α}, x ≤ z → (x ⊔ y) ⊓ z ≤ x ⊔ y ⊓ z) → motive ⋯) → motive t |
CategoryTheory.SymmetricCategory.symmetry | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.MonoidalCategory C}
[self : CategoryTheory.SymmetricCategory C] (X Y : C),
CategoryTheory.CategoryStruct.comp (β_ X Y).hom (β_ Y X).hom =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) |
CategoryTheory.DinatTrans.recOn | Mathlib.CategoryTheory.DinatTrans | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F G : CategoryTheory.Functor Cᵒᵖ (CategoryTheory.Functor C D)} →
{motive : CategoryTheory.DinatTrans F G → Sort u} →
(t : CategoryTheory.DinatTrans F G) →
((app : (X : C) → (F.obj (Opposite.op X)).obj X ⟶ (G.obj (Opposite.op X)).obj X) →
(dinaturality :
∀ {X Y : C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((F.map f.op).app X)
(CategoryTheory.CategoryStruct.comp (app X) ((G.obj (Opposite.op X)).map f)) =
CategoryTheory.CategoryStruct.comp ((F.obj (Opposite.op Y)).map f)
(CategoryTheory.CategoryStruct.comp (app Y) ((G.map f.op).app Y))) →
motive { app := app, dinaturality := dinaturality }) →
motive t |
_private.Mathlib.MeasureTheory.Function.LpSeminorm.Basic.0.MeasureTheory.eLpNorm_restrict_eq_of_support_subset._simp_1_1 | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) |
CategoryTheory.Monad.ForgetCreatesColimits.liftedCoconeIsColimit._proof_4 | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T : CategoryTheory.Monad C} {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] {D : CategoryTheory.Functor J T.Algebra}
(c : CategoryTheory.Limits.Cocone (D.comp T.forget)) (t : CategoryTheory.Limits.IsColimit c)
[inst_2 : CategoryTheory.Limits.PreservesColimit (D.comp T.forget) T.toFunctor]
[inst_3 : CategoryTheory.Limits.PreservesColimit ((D.comp T.forget).comp T.toFunctor) T.toFunctor]
(s : CategoryTheory.Limits.Cocone D) (m : (CategoryTheory.Monad.ForgetCreatesColimits.liftedCocone c t).pt ⟶ s.pt),
(∀ (j : J),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Monad.ForgetCreatesColimits.liftedCocone c t).ι.app j) m =
s.ι.app j) →
m = { f := t.desc (T.forget.mapCocone s), h := ⋯ } |
HahnEmbedding.Partial.eval_zero | Mathlib.Algebra.Order.Module.HahnEmbedding | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : IsOrderedRing K] [inst_3 : Archimedean K]
{M : Type u_2} [inst_4 : AddCommGroup M] [inst_5 : LinearOrder M] [inst_6 : IsOrderedAddMonoid M]
[inst_7 : Module K M] [inst_8 : IsOrderedModule K M] {R : Type u_3} [inst_9 : AddCommGroup R]
[inst_10 : LinearOrder R] [inst_11 : Module K R] {seed : HahnEmbedding.Seed K M R} (f : HahnEmbedding.Partial seed)
[inst_12 : IsOrderedAddMonoid R] [inst_13 : Archimedean R], f.eval 0 = 0 |
LocallyCompactPair.rec | Mathlib.Topology.Defs.Filter | {X : Type u_3} →
{Y : Type u_4} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
{motive : LocallyCompactPair X Y → Sort u} →
((exists_mem_nhds_isCompact_mapsTo :
∀ {f : X → Y} {x : X} {s : Set Y},
Continuous f → s ∈ nhds (f x) → ∃ K ∈ nhds x, IsCompact K ∧ Set.MapsTo f K s) →
motive ⋯) →
(t : LocallyCompactPair X Y) → motive t |
FirstOrder.Ring.compatibleRingOfRingStructure | Mathlib.ModelTheory.Algebra.Ring.Basic | (R : Type u_2) → [inst : FirstOrder.Language.ring.Structure R] → FirstOrder.Ring.CompatibleRing R |
Frm.coe_of | Mathlib.Order.Category.Frm | ∀ (X : Type u) [inst : Order.Frame X], ↑{ carrier := X, str := inst } = X |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.