name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.PrettyPrinter.Delaborator.delabApp | Lean.PrettyPrinter.Delaborator.Builtins | Lean.PrettyPrinter.Delaborator.Delab |
Aesop.GoalState.provenByNormalization | Aesop.Tree.Data | Aesop.GoalState |
Std.ExtDTreeMap.Const.insertMany_cons | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{l : List (α × β)} {p : α × β},
Std.ExtDTreeMap.Const.insertMany t (p :: l) = Std.ExtDTreeMap.Const.insertMany (t.insert p.1 p.2) l |
sq_le_sq₀ | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : LinearOrder M₀] [PosMulStrictMono M₀] {a b : M₀} [MulPosMono M₀],
0 ≤ a → 0 ≤ b → (a ^ 2 ≤ b ^ 2 ↔ a ≤ b) |
ProbabilityTheory.Kernel.iIndepFun_zero_right | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {β : ι → Type u_10} {m : (x : ι) → MeasurableSpace (β x)} {f : (x : ι) → Ω → β x},
ProbabilityTheory.Kernel.iIndepFun f κ 0 |
Turing.TM0to1.trCfg | Mathlib.Computability.PostTuringMachine | {Γ : Type u_1} →
[inst : Inhabited Γ] →
{Λ : Type u_2} →
[inst_1 : Inhabited Λ] →
Turing.TM0.Machine Γ Λ → Turing.TM0.Cfg Γ Λ → Turing.TM1.Cfg Γ (Turing.TM0to1.Λ' Γ Λ) Unit |
Set.piecewise_insert_self | Mathlib.Data.Set.Piecewise | ∀ {α : Type u_1} {δ : α → Sort u_7} (s : Set α) (f g : (i : α) → δ i) {j : α}
[inst : (i : α) → Decidable (i ∈ insert j s)], (insert j s).piecewise f g j = f j |
FundamentalGroupoidFunctor.piToPiTop_map | Mathlib.AlgebraicTopology.FundamentalGroupoid.Product | ∀ {I : Type u} (X : I → TopCat) {X_1 Y : (i : I) → ↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj (X i))}
(p : X_1 ⟶ Y), (FundamentalGroupoidFunctor.piToPiTop X).map p = Path.Homotopic.pi p |
Lean.Meta.instDecidableEqProjReductionKind._proof_2 | Lean.Meta.Basic | ∀ (x y : Lean.Meta.ProjReductionKind), ¬x.ctorIdx = y.ctorIdx → x = y → False |
Real.coshOpenPartialHomeomorph._proof_7 | Mathlib.Analysis.SpecialFunctions.Arcosh | ContinuousOn Real.arcosh (Set.Ioi 1) |
Std.Internal.IO.Async.System.GroupId.rec | Std.Internal.Async.System | {motive : Std.Internal.IO.Async.System.GroupId → Sort u} →
((toNat : ℕ) → motive { toNat := toNat }) → (t : Std.Internal.IO.Async.System.GroupId) → motive t |
CategoryTheory.Limits.ReflectsCofilteredLimitsOfSize.reflects_cofiltered_limits | Mathlib.CategoryTheory.Limits.Preserves.Filtered | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {D : Type u₂} {inst_1 : CategoryTheory.Category.{v₂, u₂} D}
{F : CategoryTheory.Functor C D}
[self : CategoryTheory.Limits.ReflectsCofilteredLimitsOfSize.{w', w, v₁, v₂, u₁, u₂} F] (J : Type w)
[inst_2 : CategoryTheory.Category.{w', w} J] [CategoryTheory.IsCofiltered J],
CategoryTheory.Limits.ReflectsLimitsOfShape J F |
Complex.logDeriv_exp | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | logDeriv Complex.exp = 1 |
MeasureTheory.AEStronglyMeasurable._auto_1 | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | Lean.Syntax |
CategoryTheory.PreOneHypercover.Homotopy.mk | Mathlib.CategoryTheory.Sites.Hypercover.Homotopy | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S : C} →
{E : CategoryTheory.PreOneHypercover S} →
{F : CategoryTheory.PreOneHypercover S} →
{f g : E.Hom F} →
(H : (i : E.I₀) → F.I₁ (f.s₀ i) (g.s₀ i)) →
(a : (i : E.I₀) → E.X i ⟶ F.Y (H i)) →
(∀ (i : E.I₀), CategoryTheory.CategoryStruct.comp (a i) (F.p₁ (H i)) = f.h₀ i) →
(∀ (i : E.I₀), CategoryTheory.CategoryStruct.comp (a i) (F.p₂ (H i)) = g.h₀ i) →
CategoryTheory.PreOneHypercover.Homotopy f g |
Std.Time.TimeZone.TZif.Header | Std.Time.Zoned.Database.TzIf | Type |
AlgEquiv.toOpposite._proof_1 | Mathlib.Algebra.Algebra.Opposite | ∀ (A : Type u_1) [inst : CommSemiring A] (x y : A),
(RingEquiv.toOpposite A).toFun (x * y) = (RingEquiv.toOpposite A).toFun x * (RingEquiv.toOpposite A).toFun y |
Std.Tactic.BVDecide.BVExpr.bitblast.ExtractTarget.vec | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{len : ℕ} → (self : Std.Tactic.BVDecide.BVExpr.bitblast.ExtractTarget aig len) → aig.RefVec self.w |
Lean.Meta.SynthInstance.Answer.noConfusionType | Lean.Meta.SynthInstance | Sort u → Lean.Meta.SynthInstance.Answer → Lean.Meta.SynthInstance.Answer → Sort u |
SimpleGraph.edist_bot_of_ne | Mathlib.Combinatorics.SimpleGraph.Metric | ∀ {V : Type u_1} {u v : V}, u ≠ v → ⊥.edist u v = ⊤ |
SimplicialObject.Splitting.toKaroubiNondegComplexIsoN₁._proof_9 | Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : CategoryTheory.SimplicialObject C}
(s : SimplicialObject.Splitting X) [inst_1 : CategoryTheory.Preadditive C],
CategoryTheory.CategoryStruct.comp
{
f :=
{ f := fun n => s.πSummand (SimplicialObject.Splitting.IndexSet.id (Opposite.op (SimplexCategory.mk n))),
comm' := ⋯ },
comm := ⋯ }
{
f :=
{
f := fun n =>
CategoryTheory.CategoryStruct.comp
((s.cofan (Opposite.op (SimplexCategory.mk n))).inj
(SimplicialObject.Splitting.IndexSet.id (Opposite.op (SimplexCategory.mk n))))
(AlgebraicTopology.DoldKan.PInfty.f n),
comm' := ⋯ },
comm := ⋯ } =
CategoryTheory.CategoryStruct.id (AlgebraicTopology.DoldKan.N₁.obj X) |
Polynomial.taylorEquiv.eq_1 | Mathlib.RingTheory.Polynomial.DegreeLT | ∀ {R : Type u_1} [inst : CommRing R] (r : R),
Polynomial.taylorEquiv r =
{ toFun := (↑↑(Polynomial.taylorAlgHom r).toRingHom).toFun, invFun := ⇑(Polynomial.taylorAlgHom (-r)),
left_inv := ⋯, right_inv := ⋯, map_mul' := ⋯, map_add' := ⋯, commutes' := ⋯ } |
String.singleton_ne_empty | Init.Data.String.Lemmas.Basic | ∀ {c : Char}, String.singleton c ≠ "" |
Equidecomp.ctorIdx | Mathlib.Algebra.Group.Action.Equidecomp | {X : Type u_1} → {G : Type u_2} → {inst : SMul G X} → Equidecomp X G → ℕ |
UInt16.xor_zero | Init.Data.UInt.Bitwise | ∀ {a : UInt16}, a ^^^ 0 = a |
finrank_eq_one_iff_of_nonzero | Mathlib.LinearAlgebra.FiniteDimensional.Basic | ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] (v : V),
v ≠ 0 → (Module.finrank K V = 1 ↔ K ∙ v = ⊤) |
PFunctor.M.iselect | Mathlib.Data.PFunctor.Univariate.M | {F : PFunctor.{uA, uB}} → [DecidableEq F.A] → [Inhabited F.M] → PFunctor.Approx.Path F → F.M → F.A |
AddActionHom.embMap._proof_1 | Mathlib.GroupTheory.GroupAction.MultipleTransitivity | ∀ (G : Type u_4) (α : Type u_2) [inst : AddGroup G] [inst_1 : AddAction G α] {m : Type u_3} {n : Type u_1} (e : m ↪ n)
(x : G) (x_1 : n ↪ α), e.trans (x +ᵥ x_1) = e.trans (x +ᵥ x_1) |
SimpleGraph.IsClique.finsetMap | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {β : Type u_2} {G : SimpleGraph α} {f : α ↪ β} {s : Finset α},
G.IsClique ↑s → (SimpleGraph.map (⇑f) G).IsClique ↑(Finset.map f s) |
Polynomial.polynomial_map_coe | Mathlib.RingTheory.PowerSeries.Basic | ∀ {U : Type u_2} {V : Type u_3} [inst : CommSemiring U] [inst_1 : CommSemiring V] {φ : U →+* V} {f : Polynomial U},
↑(Polynomial.map φ f) = (PowerSeries.map φ) ↑f |
AddMonCat.adj | Mathlib.Algebra.Category.MonCat.Adjunctions | AddMonCat.free ⊣ CategoryTheory.forget AddMonCat |
Lean.Compiler.LCNF.MonadFVarSubst.recOn | Lean.Compiler.LCNF.CompilerM | {m : Type → Type} →
{pu : Lean.Compiler.LCNF.Purity} →
{translator : Bool} →
{motive : Lean.Compiler.LCNF.MonadFVarSubst m pu translator → Sort u} →
(t : Lean.Compiler.LCNF.MonadFVarSubst m pu translator) →
((getSubst : m (Lean.Compiler.LCNF.FVarSubst pu)) → motive { getSubst := getSubst }) → motive t |
_private.Std.Data.ExtTreeSet.Lemmas.0.Std.ExtTreeSet.mem_ofList._simp_1_1 | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α},
(k ∈ t) = (t.contains k = true) |
CategoryTheory.Adjunction.whiskerLeftLCounitIsoOfIsIsoUnit_inv_app | Mathlib.CategoryTheory.Adjunction.FullyFaithful | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{L : CategoryTheory.Functor C D} {R : CategoryTheory.Functor D C} (h : L ⊣ R) [inst_2 : CategoryTheory.IsIso h.unit]
(X : C), h.whiskerLeftLCounitIsoOfIsIsoUnit.inv.app X = L.map (h.unit.app X) |
Action.resEquiv | Mathlib.CategoryTheory.Action.Basic | (V : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} V] →
{G : Type u_3} → {H : Type u_4} → [inst_1 : Monoid G] → [inst_2 : Monoid H] → G ≃* H → (Action V H ≌ Action V G) |
Algebra.IsSeparable.recOn | Mathlib.FieldTheory.Separable | {F : Type u_1} →
{K : Type u_3} →
[inst : CommRing F] →
[inst_1 : Ring K] →
[inst_2 : Algebra F K] →
{motive : Algebra.IsSeparable F K → Sort u} →
(t : Algebra.IsSeparable F K) → ((isSeparable' : ∀ (x : K), IsSeparable F x) → motive ⋯) → motive t |
_private.Mathlib.RingTheory.Valuation.Integers.0.Valuation.term𝓞 | Mathlib.RingTheory.Valuation.Integers | Lean.ParserDescr |
CategoryTheory.PreOneHypercover.equivalenceMulticospanOfIso._proof_1 | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {S : C} {E F : CategoryTheory.PreOneHypercover S}
(f : E ≅ F) (i : E.multicospanShape.L),
(CategoryTheory.Functor.id (CategoryTheory.Limits.WalkingMulticospan E.multicospanShape)).obj
(CategoryTheory.Limits.WalkingMulticospan.left i) =
((CategoryTheory.PreOneHypercover.Hom.mapMulticospan f.hom).comp
(CategoryTheory.PreOneHypercover.Hom.mapMulticospan f.inv)).obj
(CategoryTheory.Limits.WalkingMulticospan.left i) |
instIsAlgebraicMvPolynomialOfNoZeroDivisors_1 | Mathlib.RingTheory.Algebraic.Integral | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[alg : Algebra.IsAlgebraic R S] {σ : Type u_4} [NoZeroDivisors S],
Algebra.IsAlgebraic (MvPolynomial σ R) (MvPolynomial σ S) |
Std.DHashMap.Raw.getKeyD_eq_fallback | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {a fallback : α}, a ∉ m → m.getKeyD a fallback = fallback |
Std.TreeMap.Raw.mem_toList_iff_getKey?_eq_some_and_getElem?_eq_some | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {v : β}, (k, v) ∈ t.toList ↔ t.getKey? k = some k ∧ t[k]? = some v |
Traversable.map_eq_traverse_id | Mathlib.Control.Traversable.Lemmas | ∀ {t : Type u → Type u} [inst : Traversable t] [LawfulTraversable t] {β γ : Type u} (f : β → γ),
Functor.map f = Id.run ∘ traverse (pure ∘ f) |
CategoryTheory.Limits.CatCospanTransform.category._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u_1} {B : Type u_6} {C : Type u_10} {A' : Type u_11} {B' : Type u_3} {C' : Type u_12}
[inst : CategoryTheory.Category.{u_4, u_1} A] [inst_1 : CategoryTheory.Category.{u_5, u_6} B]
[inst_2 : CategoryTheory.Category.{u_7, u_10} C] {F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
[inst_3 : CategoryTheory.Category.{u_8, u_11} A'] [inst_4 : CategoryTheory.Category.{u_2, u_3} B']
[inst_5 : CategoryTheory.Category.{u_9, u_12} C'] {F' : CategoryTheory.Functor A' B'}
{G' : CategoryTheory.Functor C' B'} (ψ : CategoryTheory.Limits.CatCospanTransform F G F' G'),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CatCommSq.iso F ψ.left ψ.base F').hom
(CategoryTheory.Functor.whiskerRight (CategoryTheory.CategoryStruct.id ψ.left) F') =
CategoryTheory.CategoryStruct.comp (F.whiskerLeft (CategoryTheory.CategoryStruct.id ψ.base))
(CategoryTheory.CatCommSq.iso F ψ.left ψ.base F').hom |
CategoryTheory.Limits.IsInitial.uniqueUpToIso_inv | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {I I' : C} (hI : CategoryTheory.Limits.IsInitial I)
(hI' : CategoryTheory.Limits.IsInitial I'), (hI.uniqueUpToIso hI').inv = hI'.to I |
MvQPF.noConfusion | Mathlib.Data.QPF.Multivariate.Basic | {P : Sort u_2} →
{n : ℕ} →
{F : TypeVec.{u} n → Type u_1} →
{t : MvQPF F} →
{n' : ℕ} →
{F' : TypeVec.{u} n' → Type u_1} → {t' : MvQPF F'} → n = n' → F ≍ F' → t ≍ t' → MvQPF.noConfusionType P t t' |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.MulEqProof.casesOn | Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof | {motive : Lean.Meta.Grind.Arith.Cutsat.MulEqProof✝ → Sort u} →
(t : Lean.Meta.Grind.Arith.Cutsat.MulEqProof✝¹) →
((k : ℤ) → (h : Lean.Expr) → motive (Lean.Meta.Grind.Arith.Cutsat.MulEqProof.const✝ k h)) →
((k : ℤ) → (a h : Lean.Expr) → motive (Lean.Meta.Grind.Arith.Cutsat.MulEqProof.mulVar✝ k a h)) →
motive Lean.Meta.Grind.Arith.Cutsat.MulEqProof.none✝ → motive t |
Finset.notMem_map_subtype_of_not_property | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {p : α → Prop} (s : Finset { x // p x }) {a : α},
¬p a → a ∉ Finset.map (Function.Embedding.subtype fun x => p x) s |
_private.Lean.Environment.0.Lean.VisibilityMap.public | Lean.Environment | {α : Type} → Lean.VisibilityMap✝ α → α |
Aesop.ElabRuleTerm.term | Aesop.RuleTac.RuleTerm | Lean.Term → Lean.Expr → Aesop.ElabRuleTerm |
CategoryTheory.Core.inclusion_obj | Mathlib.CategoryTheory.Core | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (self : CategoryTheory.Core C),
(CategoryTheory.Core.inclusion C).obj self = self.of |
monotone_iff_apply₂ | Mathlib.Order.Monotone.Defs | ∀ {ι : Type u_1} {α : Type u} {β : ι → Type u_4} [inst : (i : ι) → Preorder (β i)] [inst_1 : Preorder α]
{f : α → (i : ι) → β i}, Monotone f ↔ ∀ (i : ι), Monotone fun x => f x i |
ContDiffMapSupportedIn.postcompCLM._proof_1 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {𝕜 : Type u_4} {E : Type u_2} {F : Type u_1} {F' : Type u_3} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F]
[inst_5 : NormedSpace 𝕜 F] [inst_6 : SMulCommClass ℝ 𝕜 F] [inst_7 : NormedAddCommGroup F'] [inst_8 : NormedSpace ℝ F']
[inst_9 : NormedSpace 𝕜 F'] [inst_10 : SMulCommClass ℝ 𝕜 F'] {n : ℕ∞} {K : TopologicalSpace.Compacts E}
[inst_11 : LinearMap.CompatibleSMul F F' ℝ 𝕜] (T : F →L[𝕜] F'), Continuous ⇑(ContDiffMapSupportedIn.postcompLM T) |
_private.Lean.Meta.LitValues.0.Lean.Meta.getRatValue?.getRatValueNum? | Lean.Meta.LitValues | Lean.Expr → Lean.MetaM (Option ℚ) |
Set.Nonempty.not_disjoint | Mathlib.Data.Set.Disjoint | ∀ {α : Type u} {s t : Set α}, (s ∩ t).Nonempty → ¬Disjoint s t |
MvPolynomial.finitePresentation_universalFactorizationMap | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ (R : Type u_1) [inst : CommRing R] (n m k : ℕ) (hn : n = m + k),
(MvPolynomial.universalFactorizationMap R n m k hn).FinitePresentation |
_private.Lean.Meta.Tactic.Simp.Arith.Int.Simp.0.Int.Linear.Poly.gcdCoeffs'.go._sunfold | Lean.Meta.Tactic.Simp.Arith.Int.Simp | ℕ → Int.Linear.Poly → ℕ |
CategoryTheory.Subobject.sup_factors_of_factors_left | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasImages C]
[inst_2 : CategoryTheory.Limits.HasBinaryCoproducts C] {A B : C} {X Y : CategoryTheory.Subobject B} {f : A ⟶ B},
X.Factors f → (X ⊔ Y).Factors f |
CategoryTheory.RelCat.opEquivalence._proof_2 | Mathlib.CategoryTheory.Category.RelCat | ∀ (X : CategoryTheory.RelCat),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.RelCat.opFunctor.map
((CategoryTheory.Iso.refl (CategoryTheory.Functor.id CategoryTheory.RelCat)).hom.app X))
((CategoryTheory.Iso.refl (CategoryTheory.RelCat.unopFunctor.comp CategoryTheory.RelCat.opFunctor)).hom.app
(CategoryTheory.RelCat.opFunctor.obj X)) =
CategoryTheory.CategoryStruct.id (CategoryTheory.RelCat.opFunctor.obj X) |
_private.Batteries.Data.String.Lemmas.0.Substring.Raw.Valid.nextn.match_1_1 | Batteries.Data.String.Lemmas | ∀ {m₁ m₂ : List Char} (motive : (x : Substring.Raw) → x.Valid → x.toString.toList = m₁ ++ m₂ → Prop) (x : Substring.Raw)
(x_1 : x.Valid) (x_2 : x.toString.toList = m₁ ++ m₂),
(∀ (x : Substring.Raw) (h : x.Valid) (e : x.toString.toList = m₁ ++ m₂), motive x h e) → motive x x_1 x_2 |
Equiv.Set.univPi | Mathlib.Logic.Equiv.Set | {α : Type u_3} → {β : α → Type u_4} → (s : (a : α) → Set (β a)) → ↑(Set.univ.pi s) ≃ ((a : α) → ↑(s a)) |
MeasureTheory.L1.edist_def | Mathlib.MeasureTheory.Function.L1Space.AEEqFun | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
(f g : ↥(MeasureTheory.Lp β 1 μ)), edist f g = ∫⁻ (a : α), edist (↑↑f a) (↑↑g a) ∂μ |
CategoryTheory.sheafSections | Mathlib.CategoryTheory.Sites.Sheaf | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(A : Type u₂) →
[inst_1 : CategoryTheory.Category.{v₂, u₂} A] →
CategoryTheory.Functor Cᵒᵖ (CategoryTheory.Functor (CategoryTheory.Sheaf J A) A) |
PMF.bindOnSupport_pure | Mathlib.Probability.ProbabilityMassFunction.Monad | ∀ {α : Type u_1} (p : PMF α), (p.bindOnSupport fun a x => PMF.pure a) = p |
WeierstrassCurve.Jacobian.Point.noConfusion | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | {P : Sort u} →
{R : Type r} →
{inst : CommRing R} →
{W' : WeierstrassCurve.Jacobian R} →
{t : W'.Point} →
{R' : Type r} →
{inst' : CommRing R'} →
{W'' : WeierstrassCurve.Jacobian R'} →
{t' : W''.Point} →
R = R' → inst ≍ inst' → W' ≍ W'' → t ≍ t' → WeierstrassCurve.Jacobian.Point.noConfusionType P t t' |
Subgroup.isCyclic | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ {α : Type u_1} [inst : Group α] [IsCyclic α] (H : Subgroup α), IsCyclic ↥H |
Nat.find_add | Mathlib.Data.Nat.Find | ∀ {n : ℕ} {p : ℕ → Prop} [inst : DecidablePred p] {hₘ : ∃ m, p (m + n)} {hₙ : ∃ n, p n},
n ≤ Nat.find hₙ → Nat.find hₘ + n = Nat.find hₙ |
ZeroHom.instSub | Mathlib.Algebra.Group.Hom.Basic | {M : Type u_2} → {N : Type u_3} → [inst : Zero M] → [inst_1 : SubtractionMonoid N] → Sub (ZeroHom M N) |
Bool.and_not_self | Init.Data.Bool | ∀ (x : Bool), (x && !x) = false |
AlgebraicGeometry.IsReduced.rec | Mathlib.AlgebraicGeometry.Properties | {X : AlgebraicGeometry.Scheme} →
{motive : AlgebraicGeometry.IsReduced X → Sort u} →
((component_reduced : ∀ (U : X.Opens), IsReduced ↑(X.presheaf.obj (Opposite.op U))) → motive ⋯) →
(t : AlgebraicGeometry.IsReduced X) → motive t |
_private.Mathlib.Algebra.Star.SelfAdjoint.0.skewAdjoint.conjugate._simp_1_1 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : AddCommGroup R] [inst_1 : StarAddMonoid R] {x : R}, (x ∈ skewAdjoint R) = (star x = -x) |
Mathlib.Tactic.Ring.inv_zero | Mathlib.Tactic.Ring.Common | ∀ {R : Type u_2} [inst : Semifield R], 0⁻¹ = 0 |
AlgebraicGeometry.Scheme.instIsOverFstOverInferInstanceOverClassId | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {M S : AlgebraicGeometry.Scheme} [inst : M.Over S],
AlgebraicGeometry.Scheme.Hom.IsOver (CategoryTheory.Limits.pullback.fst (M ↘ S) (CategoryTheory.CategoryStruct.id S))
S |
List.forIn'_nil | Init.Data.List.Control | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] {f : (a : α) → a ∈ [] → β → m (ForInStep β)}
{b : β}, forIn' [] b f = pure b |
BoolRing.hasForgetToBoolAlg._proof_2 | Mathlib.Algebra.Category.BoolRing | ∀ {X Y Z : BoolRing} (f : X ⟶ Y) (g : Y ⟶ Z),
BoolAlg.ofHom (BoolRing.Hom.hom (CategoryTheory.CategoryStruct.comp f g)).asBoolAlg =
CategoryTheory.CategoryStruct.comp (BoolAlg.ofHom (BoolRing.Hom.hom f).asBoolAlg)
(BoolAlg.ofHom (BoolRing.Hom.hom g).asBoolAlg) |
cfcₙ_sum._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax |
_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.mergeSortTR.run.eq_1 | Init.Data.List.Sort.Impl | ∀ {α : Type u_1} (le : α → α → Bool) (property : [].length = 0),
List.MergeSort.Internal.mergeSortTR.run✝ le ⟨[], property⟩ = [] |
WeierstrassCurve.Affine.Point.instAddCommGroup._proof_7 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {F : Type u_1} [inst : Field F] {W : WeierstrassCurve.Affine F} [inst_1 : DecidableEq F] (a : W.Point), a + 0 = a |
AddEquiv.val_neg_piAddUnits_symm_apply | Mathlib.Algebra.Group.Pi.Units | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → AddMonoid (M i)] (f : (i : ι) → AddUnits (M i)) (x : ι),
↑(-AddEquiv.piAddUnits.symm f) x = (f x).neg |
_private.Init.Data.Iterators.Lemmas.Combinators.FlatMap.0.Std.Iter.step_flatMapAfterM.match_3.eq_3 | Init.Data.Iterators.Lemmas.Combinators.FlatMap | ∀ {α₂ γ : Type u_1} {m : Type u_1 → Type u_2} [inst : Std.Iterator α₂ m γ] (it₂ : Std.IterM m γ)
(motive : it₂.Step → Sort u_3) (h : it₂.IsPlausibleStep Std.IterStep.done)
(h_1 :
(it₂' : Std.IterM m γ) →
(out : γ) → (h : it₂.IsPlausibleStep (Std.IterStep.yield it₂' out)) → motive ⟨Std.IterStep.yield it₂' out, h⟩)
(h_2 :
(it₂' : Std.IterM m γ) → (h : it₂.IsPlausibleStep (Std.IterStep.skip it₂')) → motive ⟨Std.IterStep.skip it₂', h⟩)
(h_3 : (h : it₂.IsPlausibleStep Std.IterStep.done) → motive ⟨Std.IterStep.done, h⟩),
(match ⟨Std.IterStep.done, h⟩ with
| ⟨Std.IterStep.yield it₂' out, h⟩ => h_1 it₂' out h
| ⟨Std.IterStep.skip it₂', h⟩ => h_2 it₂' h
| ⟨Std.IterStep.done, h⟩ => h_3 h) =
h_3 h |
MeasureTheory.Integrable.integral_norm_condKernel | Mathlib.Probability.Kernel.Disintegration.Integral | ∀ {α : Type u_1} {Ω : Type u_2} {F : Type u_4} {mα : MeasurableSpace α} [inst : MeasurableSpace Ω]
[inst_1 : StandardBorelSpace Ω] [inst_2 : Nonempty Ω] [inst_3 : NormedAddCommGroup F]
{ρ : MeasureTheory.Measure (α × Ω)} [inst_4 : MeasureTheory.IsFiniteMeasure ρ] {f : α × Ω → F},
MeasureTheory.Integrable f ρ → MeasureTheory.Integrable (fun x => ∫ (y : Ω), ‖f (x, y)‖ ∂ρ.condKernel x) ρ.fst |
Matrix.BlockTriangular.mul | Mathlib.LinearAlgebra.Matrix.Block | ∀ {α : Type u_1} {m : Type u_3} {R : Type v} {b : m → α} [inst : LinearOrder α] [inst_1 : Fintype m]
[inst_2 : NonUnitalNonAssocSemiring R] {M N : Matrix m m R},
M.BlockTriangular b → N.BlockTriangular b → (M * N).BlockTriangular b |
moduleTopology | Mathlib.Topology.Algebra.Module.ModuleTopology | (R : Type u_1) → [TopologicalSpace R] → (A : Type u_2) → [Add A] → [SMul R A] → TopologicalSpace A |
Lean.instReprKVMap | Lean.Data.KVMap | Repr Lean.KVMap |
_private.Mathlib.Algebra.Order.GroupWithZero.Lex.0.MonoidWithZeroHom.snd_mono._simp_1_2 | Mathlib.Algebra.Order.GroupWithZero.Lex | ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] {x y : α × β}, (x ≤ y) = (x.1 ≤ y.1 ∧ x.2 ≤ y.2) |
Matroid.exists_isBasis._auto_1 | Mathlib.Combinatorics.Matroid.Basic | Lean.Syntax |
AddSubmonoid.comap_surjective_of_injective | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_4}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F},
Function.Injective ⇑f → Function.Surjective (AddSubmonoid.comap f) |
Nat.count_eq_card_filter_range | Mathlib.Data.Nat.Count | ∀ (p : ℕ → Prop) [inst : DecidablePred p] (n : ℕ), Nat.count p n = {x ∈ Finset.range n | p x}.card |
ContinuousAffineEquiv.instEquivLike._proof_2 | Mathlib.Topology.Algebra.ContinuousAffineEquiv | ∀ {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 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : TopologicalSpace P₁]
[inst_5 : AddCommGroup V₂] [inst_6 : Module k V₂] [inst_7 : AddTorsor V₂ P₂] [inst_8 : TopologicalSpace P₂]
(f : P₁ ≃ᴬ[k] P₂), Function.RightInverse (↑f).invFun (↑f).toFun |
CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse_map_left_left | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor T D) (Y : D) (X : T)
{X_1 Y_1 : CategoryTheory.CostructuredArrow ((CategoryTheory.Over.forget X).comp F) Y} (g : X_1 ⟶ Y_1),
((CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse F Y X).map g).left.left = g.left.left |
Turing.PartrecToTM2.instDecidableEqCont'.decEq._proof_2 | Mathlib.Computability.TMToPartrec | ∀ (a : Turing.PartrecToTM2.Cont'), a.cons₂ = a.cons₂ |
Filter.NeBot.coprodᵢ | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} [∀ (i : ι), Nonempty (α i)] {i : ι},
(f i).NeBot → (Filter.coprodᵢ f).NeBot |
Lean.Elab.Tactic.Do.ProofMode.elabMLeft._regBuiltin.Lean.Elab.Tactic.Do.ProofMode.elabMLeft_1 | Lean.Elab.Tactic.Do.ProofMode.LeftRight | IO Unit |
Lean.Linter.UnusedVariables.FVarDefinition.noConfusion | Lean.Linter.UnusedVariables | {P : Sort u} →
{t t' : Lean.Linter.UnusedVariables.FVarDefinition} →
t = t' → Lean.Linter.UnusedVariables.FVarDefinition.noConfusionType P t t' |
_private.Mathlib.Data.Ordmap.Invariants.0.Ordnode.splitMin'.match_1.splitter | Mathlib.Data.Ordmap.Invariants | {α : Type u_1} →
(motive : α × Ordnode α → Sort u_2) → (x : α × Ordnode α) → ((xm : α) → (l' : Ordnode α) → motive (xm, l')) → motive x |
Finset.nsmul | Mathlib.Algebra.Group.Pointwise.Finset.Basic | {α : Type u_2} → [DecidableEq α] → [Zero α] → [Add α] → SMul ℕ (Finset α) |
MulPosReflectLE.toMulPosReflectLT | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {α : Type u_1} [inst : MulZeroClass α] [inst_1 : PartialOrder α] [MulPosReflectLE α], MulPosReflectLT α |
BitVec.intMin_sle | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x : BitVec w), (BitVec.intMin w).sle x = true |
Std.Time.Formats.leanDate | Std.Time.Format | Std.Time.GenericFormat Std.Time.Awareness.any |
AlgebraicGeometry.Scheme.Pullback.pullbackFstιToV_snd | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z)
[inst : ∀ (i : 𝒰.I₀), CategoryTheory.Limits.HasPullback (CategoryTheory.CategoryStruct.comp (𝒰.f i) f) g]
(i j : 𝒰.I₀),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Pullback.pullbackFstιToV 𝒰 f g i j)
(CategoryTheory.Limits.pullback.snd
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.fst (CategoryTheory.CategoryStruct.comp (𝒰.f j) f) g) (𝒰.f j))
(𝒰.f i)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.fst
(CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Scheme.Pullback.p1 𝒰 f g) (𝒰.f i))
((AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).ι j))
(CategoryTheory.Limits.pullback.snd (AlgebraicGeometry.Scheme.Pullback.p1 𝒰 f g) (𝒰.f i)) |
MvPolynomial.supported_le_supported_iff._simp_1 | Mathlib.Algebra.MvPolynomial.Supported | ∀ {σ : Type u_1} {R : Type u} [inst : CommSemiring R] {s t : Set σ} [Nontrivial R],
(MvPolynomial.supported R s ≤ MvPolynomial.supported R t) = (s ⊆ t) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.