name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
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
|
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
|
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} →
{translator : Bool} →
{motive : Lean.Compiler.LCNF.MonadFVarSubst m translator → Sort u} →
(t : Lean.Compiler.LCNF.MonadFVarSubst m translator) →
((getSubst : m Lean.Compiler.LCNF.FVarSubst) → 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
|
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 (CategoryTheory.CategoryStruct.id (F.comp ψ.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
|
OreLocalization.instDistribMulActionOfIsScalarTower.congr_simp
|
Mathlib.RingTheory.OreLocalization.Ring
|
∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {X : Type u_2}
[inst_2 : AddMonoid X] [inst_3 : DistribMulAction R X] {R₀ : Type u_3} [inst_4 : Monoid R₀] [inst_5 : MulAction R₀ X]
[inst_6 : MulAction R₀ R] [inst_7 : IsScalarTower R₀ R X] [inst_8 : IsScalarTower R₀ R R],
OreLocalization.instDistribMulActionOfIsScalarTower = OreLocalization.instDistribMulActionOfIsScalarTower
|
CategoryTheory.RelCat.opEquivalence._proof_2
|
Mathlib.CategoryTheory.Category.RelCat
|
∀ (X_1 : CategoryTheory.RelCat),
CategoryTheory.CategoryStruct.comp (CategoryTheory.RelCat.opFunctor.map (CategoryTheory.CategoryStruct.id X_1))
(CategoryTheory.CategoryStruct.id (CategoryTheory.RelCat.opFunctor.obj X_1)) =
CategoryTheory.CategoryStruct.id (CategoryTheory.RelCat.opFunctor.obj X_1)
|
_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.Basic
|
∀ {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] (n : ℕ) (a : W.Point),
zsmulRec nsmulRec (Int.negSucc n) a = zsmulRec nsmulRec (Int.negSucc n) 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
|
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)
|
Complex.ofReal_one
|
Mathlib.Data.Complex.Basic
|
↑1 = 1
|
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_srem._simp_1_6
|
Init.Data.BitVec.Bitblast
|
∀ {p : Prop} {x : Decidable p}, (decide p = false) = ¬p
|
Lean.Compiler.LCNF.CompilerM.Context.noConfusionType
|
Lean.Compiler.LCNF.CompilerM
|
Sort u → Lean.Compiler.LCNF.CompilerM.Context → Lean.Compiler.LCNF.CompilerM.Context → Sort u
|
Multiset.decidableDexistsMultiset._proof_1
|
Mathlib.Data.Multiset.Defs
|
∀ {α : Type u_1} {m : Multiset α} {p : (a : α) → a ∈ m → Prop}, (∃ x ∈ m.attach, p ↑x ⋯) ↔ ∃ a, ∃ (h : a ∈ m), p a h
|
ExteriorAlgebra.ι_eq_zero_iff._simp_1
|
Mathlib.LinearAlgebra.ExteriorAlgebra.Basic
|
∀ {R : Type u1} [inst : CommRing R] {M : Type u2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] (x : M),
((ExteriorAlgebra.ι R) x = 0) = (x = 0)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.