name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
ProbabilityTheory.mgf_congr_identDistrib | Mathlib.Probability.Moments.Basic | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω} {Ω' : Type u_3}
{mΩ' : MeasurableSpace Ω'} {μ' : MeasureTheory.Measure Ω'} {Y : Ω' → ℝ},
ProbabilityTheory.IdentDistrib X Y μ μ' → ProbabilityTheory.mgf X μ = ProbabilityTheory.mgf Y μ' |
OrderIso.sumLexIicIoi_symm_apply_Iic | Mathlib.Order.Hom.Lex | ∀ {α : Type u_1} [inst : LinearOrder α] {x : α} (a : ↑(Set.Iic x)), (OrderIso.sumLexIicIoi x).symm ↑a = Sum.inl a |
ProofWidgets.Html._sizeOf_1 | ProofWidgets.Data.Html | ProofWidgets.Html → ℕ |
_private.Mathlib.Topology.Instances.EReal.Lemmas.0.EReal.continuousAt_mul_top_pos._simp_1_9 | Mathlib.Topology.Instances.EReal.Lemmas | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (a < max b c) = (a < b ∨ a < c) |
CategoryTheory.Mon.Hom.mk.sizeOf_spec | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{M N : CategoryTheory.Mon C} [inst_2 : SizeOf C] (hom : M.X ⟶ N.X) [isMonHom_hom : CategoryTheory.IsMonHom hom],
sizeOf { hom := hom, isMonHom_hom := isMonHom_hom } = 1 + sizeOf hom + sizeOf isMonHom_hom |
Lean.Elab.Tactic.nonempty_to_inhabited | Mathlib.Tactic.Inhabit | (α : Sort u_1) → Nonempty α → Inhabited α |
AlgebraicGeometry.IsLocalIso.instIsMultiplicativeScheme | Mathlib.AlgebraicGeometry.Morphisms.LocalIso | CategoryTheory.MorphismProperty.IsMultiplicative @AlgebraicGeometry.IsLocalIso |
Lean.Elab.Tactic.Do.Fuel.recOn | Lean.Elab.Tactic.Do.VCGen.Basic | {motive : Lean.Elab.Tactic.Do.Fuel → Sort u} →
(t : Lean.Elab.Tactic.Do.Fuel) →
((n : ℕ) → motive (Lean.Elab.Tactic.Do.Fuel.limited n)) → motive Lean.Elab.Tactic.Do.Fuel.unlimited → motive t |
NonemptyChain.rec | Mathlib.Order.BourbakiWitt | {α : Type u_2} →
[inst : LE α] →
{motive : NonemptyChain α → Sort u} →
((carrier : Set α) →
(Nonempty' : carrier.Nonempty) →
(isChain' : IsChain (fun x1 x2 => x1 ≤ x2) carrier) →
motive { carrier := carrier, Nonempty' := Nonempty', isChain' := isChain' }) →
(t : NonemptyChain α) → motive t |
le_of_pow_le_pow_left₀ | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : LinearOrder M₀] [PosMulStrictMono M₀] {a b : M₀} {n : ℕ}
[MulPosMono M₀], n ≠ 0 → 0 ≤ b → a ^ n ≤ b ^ n → a ≤ b |
PadicAlgCl.valuation_p | Mathlib.NumberTheory.Padics.Complex | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)], Valued.v ↑p = 1 / ↑p |
Nat.map_cast_int_atTop | Mathlib.Order.Filter.AtTopBot.Basic | Filter.map Nat.cast Filter.atTop = Filter.atTop |
QuotientGroup.mk_mul | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : Group G] (N : Subgroup G) [nN : N.Normal] (a b : G), ↑(a * b) = ↑a * ↑b |
Std.DTreeMap.contains_emptyc | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {k : α}, ∅.contains k = false |
Finset.weightedVSub | Mathlib.LinearAlgebra.AffineSpace.Combination | {k : Type u_1} →
{V : Type u_2} →
{P : Type u_3} →
[inst : Ring k] →
[inst_1 : AddCommGroup V] →
[inst_2 : Module k V] → [S : AddTorsor V P] → {ι : Type u_4} → Finset ι → (ι → P) → (ι → k) →ₗ[k] V |
CategoryTheory.MorphismProperty.LeftFraction.unop_f | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W : CategoryTheory.MorphismProperty Cᵒᵖ} {X Y : Cᵒᵖ}
(φ : W.LeftFraction X Y), φ.unop.f = φ.f.unop |
MeasureTheory.AddContent.mk._flat_ctor | Mathlib.MeasureTheory.Measure.AddContent | {α : Type u_1} →
{G : Type u_2} →
[inst : AddCommMonoid G] →
{C : Set (Set α)} →
(toFun : Set α → G) →
toFun ∅ = 0 →
(∀ (I : Finset (Set α)), ↑I ⊆ C → (↑I).PairwiseDisjoint id → ⋃₀ ↑I ∈ C → toFun (⋃₀ ↑I) = ∑ u ∈ I, toFun u) →
MeasureTheory.AddContent G C |
_private.Mathlib.Tactic.Linarith.Preprocessing.0.Mathlib.Tactic.Linarith.nlinarithGetSquareProofs | Mathlib.Tactic.Linarith.Preprocessing | List Lean.Expr → Lean.MetaM (List Lean.Expr) |
Int.natCast_toNat_eq_self | Init.Data.Int.LemmasAux | ∀ {a : ℤ}, ↑a.toNat = a ↔ 0 ≤ a |
_private.Std.Tactic.BVDecide.LRAT.Internal.CompactLRATCheckerSound.0.Std.Tactic.BVDecide.LRAT.Internal.compactLratChecker.go.match_3.eq_4 | Std.Tactic.BVDecide.LRAT.Internal.CompactLRATCheckerSound | ∀ {n : ℕ} (motive : Option (Std.Tactic.BVDecide.LRAT.Internal.DefaultClauseAction n) → Sort u_1) (id : ℕ)
(c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n)
(pivot : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)) (rupHints : Array ℕ)
(ratHints : Array (ℕ × Array ℕ)) (h_1 : Unit → motive none)
(h_2 : (id : ℕ) → (rupHints : Array ℕ) → motive (some (Std.Tactic.BVDecide.LRAT.Action.addEmpty id rupHints)))
(h_3 :
(id : ℕ) →
(c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n) →
(rupHints : Array ℕ) → motive (some (Std.Tactic.BVDecide.LRAT.Action.addRup id c rupHints)))
(h_4 :
(id : ℕ) →
(c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n) →
(pivot : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)) →
(rupHints : Array ℕ) →
(ratHints : Array (ℕ × Array ℕ)) →
motive (some (Std.Tactic.BVDecide.LRAT.Action.addRat id c pivot rupHints ratHints)))
(h_5 : (ids : Array ℕ) → motive (some (Std.Tactic.BVDecide.LRAT.Action.del ids))),
(match some (Std.Tactic.BVDecide.LRAT.Action.addRat id c pivot rupHints ratHints) with
| none => h_1 ()
| some (Std.Tactic.BVDecide.LRAT.Action.addEmpty id rupHints) => h_2 id rupHints
| some (Std.Tactic.BVDecide.LRAT.Action.addRup id c rupHints) => h_3 id c rupHints
| some (Std.Tactic.BVDecide.LRAT.Action.addRat id c pivot rupHints ratHints) => h_4 id c pivot rupHints ratHints
| some (Std.Tactic.BVDecide.LRAT.Action.del ids) => h_5 ids) =
h_4 id c pivot rupHints ratHints |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_664 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax |
Filter.EventuallyEq.lieBracketWithin_vectorField_eq_of_insert | Mathlib.Analysis.Calculus.VectorField | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {V W V₁ W₁ : E → E} {s : Set E} {x : E},
V₁ =ᶠ[nhdsWithin x (insert x s)] V →
W₁ =ᶠ[nhdsWithin x (insert x s)] W →
VectorField.lieBracketWithin 𝕜 V₁ W₁ s x = VectorField.lieBracketWithin 𝕜 V W s x |
Lean.AxiomVal.isUnsafeEx | Lean.Declaration | Lean.AxiomVal → Bool |
BitVec.not_or_self | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x : BitVec w), ~~~x ||| x = BitVec.allOnes w |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabLetE._sparseCasesOn_3 | Lean.PrettyPrinter.Delaborator.Builtins | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
(Nat.hasNotBit 256 t.ctorIdx → motive t) → motive t |
Std.ExtDHashMap.getKey?_inter_of_not_mem_left | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α}, k ∉ m₁ → (m₁ ∩ m₂).getKey? k = none |
_private.Lean.Server.FileWorker.SemanticHighlighting.0.Lean.Server.FileWorker.splitStr._proof_1 | Lean.Server.FileWorker.SemanticHighlighting | ∀ (text : Lean.FileMap) (pos : String.Pos.Raw),
∀ i ∈ [(text.toPosition pos).line:text.positions.size], i < text.positions.size |
Pi.intCast_def | Mathlib.Data.Int.Cast.Pi | ∀ {ι : Type u_1} {π : ι → Type u_2} [inst : (i : ι) → IntCast (π i)] (n : ℤ), ↑n = fun x => ↑n |
CategoryTheory.ObjectProperty.ColimitOfShape._sizeOf_1 | Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape | {C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{P : CategoryTheory.ObjectProperty C} →
{J : Type u'} →
{inst_1 : CategoryTheory.Category.{v', u'} J} →
{X : C} → [SizeOf C] → [(a : C) → SizeOf (P a)] → [SizeOf J] → P.ColimitOfShape J X → ℕ |
Lean.Lsp.FoldingRangeParams.mk.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | ∀ (textDocument : Lean.Lsp.TextDocumentIdentifier), sizeOf { textDocument := textDocument } = 1 + sizeOf textDocument |
mul_self_nonneg | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] [ExistsAddOfLE R] [PosMulMono R] [AddLeftMono R] (a : R),
0 ≤ a * a |
Matroid.comap_isBasis'_iff._simp_1 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {N : Matroid β} {I X : Set α},
(N.comap f).IsBasis' I X = (N.IsBasis' (f '' I) (f '' X) ∧ Set.InjOn f I ∧ I ⊆ X) |
_private.Init.Data.Order.PackageFactories.0.Std.LinearPreorderPackage.ofOrd._simp_4 | Init.Data.Order.PackageFactories | ∀ {α : Type u} [inst : Ord α] [inst_1 : LE α] [Std.LawfulOrderOrd α] {a b : α}, ((compare a b).isGE = true) = (b ≤ a) |
Ordinal.deriv_zero_left | Mathlib.SetTheory.Ordinal.FixedPoint | ∀ (a : Ordinal.{u_1}), Ordinal.deriv 0 a = a |
SimpleGraph.completeEquipartiteGraph.completeMultipartiteGraph._proof_1 | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {r t : ℕ} {a b : Fin r × Fin t},
(SimpleGraph.completeMultipartiteGraph (Function.const (Fin r) (Fin t))).Adj
((Equiv.sigmaEquivProd (Fin r) (Fin t)).symm a) ((Equiv.sigmaEquivProd (Fin r) (Fin t)).symm b) ↔
(SimpleGraph.completeEquipartiteGraph r t).Adj a b |
Lean.Grind.Linarith.lt_norm | Init.Grind.Ordered.Linarith | ∀ {α : Type u_1} [inst : Lean.Grind.IntModule α] [inst_1 : LE α] [inst_2 : LT α] [Std.LawfulOrderLT α]
[inst_4 : Std.IsPreorder α] [Lean.Grind.OrderedAdd α] (ctx : Lean.Grind.Linarith.Context α)
(lhs rhs : Lean.Grind.Linarith.Expr) (p : Lean.Grind.Linarith.Poly),
Lean.Grind.Linarith.norm_cert lhs rhs p = true →
Lean.Grind.Linarith.Expr.denote ctx lhs < Lean.Grind.Linarith.Expr.denote ctx rhs →
Lean.Grind.Linarith.Poly.denote' ctx p < 0 |
DomMulAct.instCancelCommMonoidOfMulOpposite.eq_1 | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} [inst : CancelCommMonoid Mᵐᵒᵖ], DomMulAct.instCancelCommMonoidOfMulOpposite = inst |
Lean.Grind.CommRing.Poly.degree | Lean.Meta.Tactic.Grind.Arith.CommRing.Poly | Lean.Grind.CommRing.Poly → ℕ |
SimpleGraph.Copy.isoSubgraphMap._simp_3 | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' |
Pi.addHom.eq_1 | Mathlib.Algebra.Group.Pi.Lemmas | ∀ {I : Type u} {f : I → Type v} {γ : Type w} [inst : (i : I) → Add (f i)] [inst_1 : Add γ] (g : (i : I) → γ →ₙ+ f i),
Pi.addHom g = { toFun := fun x i => (g i) x, map_add' := ⋯ } |
Qq.Impl.unquoteExpr | Qq.Macro | Lean.Expr → Qq.Impl.UnquoteM Lean.Expr |
Nat.reduceLeDiff._regBuiltin.Nat.reduceLeDiff.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.2466209926._hygCtx._hyg.24 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | IO Unit |
_private.Mathlib.RingTheory.Valuation.Extension.0.Valuation.HasExtension.algebraMap_mem_maximalIdeal_iff._simp_1_1 | Mathlib.RingTheory.Valuation.Extension | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : IsLocalRing R] (x : R),
(x ∈ IsLocalRing.maximalIdeal R) = (x ∈ nonunits R) |
Lean.Compiler.LCNF.ConfigOptions.mk | Lean.Compiler.LCNF.ConfigOptions | ℕ → ℕ → ℕ → Bool → Bool → ℕ → Bool → Lean.Compiler.LCNF.ConfigOptions |
_private.Mathlib.Topology.Algebra.Module.LinearPMap.0.LinearPMap.inverse_isClosable_iff.match_1_1 | Mathlib.Topology.Algebra.Module.LinearPMap | ∀ {R : Type u_1} {E : Type u_3} {F : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup E] [inst_2 : AddCommGroup F]
[inst_3 : Module R E] [inst_4 : Module R F] [inst_5 : TopologicalSpace E] [inst_6 : TopologicalSpace F]
{f : E →ₗ.[R] F} [inst_7 : ContinuousAdd E] [inst_8 : ContinuousAdd F] [inst_9 : TopologicalSpace R]
[inst_10 : ContinuousSMul R E] [inst_11 : ContinuousSMul R F] (motive : f.inverse.IsClosable → Prop)
(h : f.inverse.IsClosable),
(∀ (f' : F →ₗ.[R] E) (h : f.inverse.graph.topologicalClosure = f'.graph), motive ⋯) → motive h |
ne_zero_of_dvd_ne_zero | Mathlib.Algebra.GroupWithZero.Divisibility | ∀ {α : Type u_1} [inst : MonoidWithZero α] {p q : α}, q ≠ 0 → p ∣ q → p ≠ 0 |
Lean.Meta.Canonicalizer.CanonM.run' | Lean.Meta.Canonicalizer | {α : Type} →
Lean.Meta.CanonM α →
optParam Lean.Meta.TransparencyMode Lean.Meta.TransparencyMode.instances →
optParam Lean.Meta.Canonicalizer.State { } → Lean.MetaM α |
_private.Mathlib.Data.Ordmap.Invariants.0.Ordnode.splitMax_eq.match_1_1 | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} (motive : ℕ → Ordnode α → α → Ordnode α → Prop) (x : ℕ) (x_1 : Ordnode α) (x_2 : α) (x_3 : Ordnode α),
(∀ (x : ℕ) (x_4 : Ordnode α) (x_5 : α), motive x x_4 x_5 Ordnode.nil) →
(∀ (x : ℕ) (l : Ordnode α) (x_4 : α) (ls : ℕ) (ll : Ordnode α) (lx : α) (lr : Ordnode α),
motive x l x_4 (Ordnode.node ls ll lx lr)) →
motive x x_1 x_2 x_3 |
Bool.dite_else_false._simp_1 | Init.PropLemmas | ∀ {p : Prop} [inst : Decidable p] {x : p → Bool}, ((if h : p then x h else false) = true) = ∃ (h : p), x h = true |
Mathlib.Tactic.RingNF._aux_Mathlib_Tactic_Ring_RingNF___macroRules_Mathlib_Tactic_RingNF_ring_1 | Mathlib.Tactic.Ring.RingNF | Lean.Macro |
AlgebraicGeometry.instQuasiCompactLiftSchemeIdOfQuasiSeparatedSpaceCarrierCarrierCommRingCat | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | ∀ {X : AlgebraicGeometry.Scheme} [QuasiSeparatedSpace ↥X],
AlgebraicGeometry.QuasiCompact
(CategoryTheory.Limits.prod.lift (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id X)) |
Pi.subtractionMonoid.eq_1 | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u} {f : I → Type v₁} [inst : (i : I) → SubtractionMonoid (f i)],
Pi.subtractionMonoid = { toSubNegMonoid := Pi.subNegMonoid, neg_neg := ⋯, neg_add_rev := ⋯, neg_eq_of_add := ⋯ } |
CategoryTheory.regularEpiOfEpi | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y : C} →
[CategoryTheory.IsRegularEpiCategory C] → (f : X ⟶ Y) → [CategoryTheory.Epi f] → CategoryTheory.RegularEpi f |
AddAction.toAddSemigroupAction | Mathlib.Algebra.Group.Action.Defs | {G : Type u_9} → {P : Type u_10} → {inst : AddMonoid G} → [self : AddAction G P] → AddSemigroupAction G P |
SimpContFract.IsContFract | Mathlib.Algebra.ContinuedFractions.Basic | {α : Type u_1} → [inst : One α] → [Zero α] → [LT α] → SimpContFract α → Prop |
SimpleGraph.chromaticNumber_eq_iInf | Mathlib.Combinatorics.SimpleGraph.Coloring | ∀ {V : Type u} (G : SimpleGraph V), G.chromaticNumber = ⨅ n, ↑↑n |
Finsupp.liftAddHom._proof_2 | Mathlib.Algebra.BigOperators.Finsupp.Basic | ∀ {α : Type u_1} {M : Type u_2} {N : Type u_3} [inst : AddZeroClass M] [inst_1 : AddCommMonoid N] (F : α → M →+ N)
(x x_1 : α →₀ M), ((x + x_1).sum fun x => ⇑(F x)) = (x.sum fun x => ⇑(F x)) + x_1.sum fun x => ⇑(F x) |
Mathlib.Meta.FunProp.LambdaTheorem.getProof | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.LambdaTheorem → Lean.MetaM Lean.Expr |
_private.Mathlib.Algebra.Group.Conj.0.isConj_iff_eq.match_1_1 | Mathlib.Algebra.Group.Conj | ∀ {α : Type u_1} [inst : CommMonoid α] {a b : α} (motive : IsConj a b → Prop) (x : IsConj a b),
(∀ (c : αˣ) (hc : SemiconjBy (↑c) a b), motive ⋯) → motive x |
TopCat.pullbackHomeoPreimage._proof_7 | Mathlib.Topology.Category.TopCat.Limits.Pullbacks | ∀ {X : Type u_2} {Y : Type u_3} {Z : Type u_1} (f : X → Z) (g : Y → Z) (x : ↑(f ⁻¹' Set.range g)),
f ↑x = g (Exists.choose ⋯) |
GaloisInsertion.mk._flat_ctor | Mathlib.Order.GaloisConnection.Defs | {α : Type u_2} →
{β : Type u_3} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
{l : α → β} →
{u : β → α} →
(choice : (x : α) → u (l x) ≤ x → β) →
GaloisConnection l u →
(∀ (x : β), x ≤ l (u x)) → (∀ (a : α) (h : u (l a) ≤ a), choice a h = l a) → GaloisInsertion l u |
_private.Mathlib.Analysis.BoxIntegral.Partition.Basic.0.BoxIntegral.Prepartition.filter_le.match_1_1 | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I) (p : BoxIntegral.Box ι → Prop)
(J : BoxIntegral.Box ι) (motive : J ∈ π ∧ p J → Prop) (x : J ∈ π ∧ p J),
(∀ (hπ : J ∈ π) (right : p J), motive ⋯) → motive x |
Finset.shadow_mono | Mathlib.Combinatorics.SetFamily.Shadow | ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 ℬ : Finset (Finset α)}, 𝒜 ⊆ ℬ → 𝒜.shadow ⊆ ℬ.shadow |
AlgebraicGeometry.Scheme.canonicallyOverPullback | Mathlib.AlgebraicGeometry.Pullbacks | {M S T : AlgebraicGeometry.Scheme} →
[inst : M.Over S] → {f : T ⟶ S} → (CategoryTheory.Limits.pullback (M ↘ S) f).CanonicallyOver T |
_private.Plausible.Testable.0.Plausible.Decorations._aux_Plausible_Testable___elabRules_Plausible_Decorations_tacticMk_decorations_1.match_1 | Plausible.Testable | (motive : Lean.Expr → Sort u_1) →
(goalType : Lean.Expr) →
((us : List Lean.Level) →
(body : Lean.Expr) → motive ((Lean.Expr.const `Plausible.Decorations.DecorationsOf us).app body)) →
((x : Lean.Expr) → motive x) → motive goalType |
Int32.ofIntLE_le_iff_le | Init.Data.SInt.Lemmas | ∀ {a b : ℤ} (ha₁ : Int32.minValue.toInt ≤ a) (ha₂ : a ≤ Int32.maxValue.toInt) (hb₁ : Int32.minValue.toInt ≤ b)
(hb₂ : b ≤ Int32.maxValue.toInt), Int32.ofIntLE a ha₁ ha₂ ≤ Int32.ofIntLE b hb₁ hb₂ ↔ a ≤ b |
Std.DTreeMap.Internal.Impl.Const.getD_diff_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
(h₁ : m₁.WF),
m₂.WF →
∀ {k : α} {fallback : β},
Std.DTreeMap.Internal.Impl.contains k m₁ = false →
Std.DTreeMap.Internal.Impl.Const.getD (m₁.diff m₂ ⋯) k fallback = fallback |
LieEquiv.map_lie | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieRing L₂]
[inst_3 : LieAlgebra R L₁] [inst_4 : LieAlgebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂) (x y : L₁), e ⁅x, y⁆ = ⁅e x, e y⁆ |
Std.DTreeMap.Internal.Impl.getKeyD_filter_key | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α] {f : α → Bool}
{k fallback : α} (h : t.WF),
(Std.DTreeMap.Internal.Impl.filter (fun k x => f k) t ⋯).impl.getKeyD k fallback =
(Option.filter f (t.getKey? k)).getD fallback |
_private.Lean.Meta.Match.MatchEqs.0.Lean.Meta.Match.initFn._@.Lean.Meta.Match.MatchEqs.136844199._hygCtx._hyg.2 | Lean.Meta.Match.MatchEqs | IO Unit |
Dyadic.neg.eq_1 | Init.Data.Dyadic.Basic | Dyadic.zero.neg = Dyadic.zero |
Lean.PrettyPrinter.Formatter.Context.mk.inj | Lean.PrettyPrinter.Formatter | ∀ {options : Lean.Options} {table : Lean.Parser.TokenTable} {options_1 : Lean.Options}
{table_1 : Lean.Parser.TokenTable},
{ options := options, table := table } = { options := options_1, table := table_1 } →
options = options_1 ∧ table = table_1 |
AddAction.vadd_mem_of_set_mem_fixedBy | Mathlib.GroupTheory.GroupAction.FixedPoints | ∀ {α : Type u_1} {G : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {s : Set α} {g : G},
s ∈ AddAction.fixedBy (Set α) g → ∀ {x : α}, g +ᵥ x ∈ s ↔ x ∈ s |
Set.unitEquivUnitsInteger._proof_3 | Mathlib.RingTheory.DedekindDomain.SInteger | ∀ {R : Type u_2} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (S : Set (IsDedekindDomain.HeightOneSpectrum R))
(K : Type u_1) [inst_2 : Field K] [inst_3 : Algebra R K] [inst_4 : IsFractionRing R K],
Function.RightInverse (fun x => ⟨Units.mk0 ↑↑x ⋯, ⋯⟩) fun x =>
{ val := ⟨↑↑x, ⋯⟩, inv := ⟨↑(↑x)⁻¹, ⋯⟩, val_inv := ⋯, inv_val := ⋯ } |
Lean.Lsp.instToJsonCodeActionClientCapabilities | Lean.Data.Lsp.CodeActions | Lean.ToJson Lean.Lsp.CodeActionClientCapabilities |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.OpOp.0.CategoryTheory.Pretriangulated.instIsTriangulatedOppositeOpOp._proof_2 | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | 1 + -1 = 0 |
UInt8.or_eq_zero_iff._simp_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt8}, (a ||| b = 0) = (a = 0 ∧ b = 0) |
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.combineDivCoeffs.inj | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ {c₁ c₂ : Lean.Meta.Grind.Arith.Cutsat.LeCnstr} {k : ℤ} {c₁_1 c₂_1 : Lean.Meta.Grind.Arith.Cutsat.LeCnstr} {k_1 : ℤ},
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.combineDivCoeffs c₁ c₂ k =
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.combineDivCoeffs c₁_1 c₂_1 k_1 →
c₁ = c₁_1 ∧ c₂ = c₂_1 ∧ k = k_1 |
CategoryTheory.preserves_mono_of_preservesLimit | Mathlib.CategoryTheory.Limits.Constructions.EpiMono | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y)
[CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f f) F] [CategoryTheory.Mono f],
CategoryTheory.Mono (F.map f) |
Finpartition.part | Mathlib.Order.Partition.Finpartition | {α : Type u_1} → [inst : DecidableEq α] → {s : Finset α} → Finpartition s → α → Finset α |
MeasureTheory.Lp.ext_iff | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_4} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] {f g : ↥(MeasureTheory.Lp E p μ)}, f = g ↔ ↑↑f =ᵐ[μ] ↑↑g |
LinearMap.coprod_comp_inl_inr | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {M₂ : Type w} {M₃ : Type y} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module R M₂]
[inst_6 : Module R M₃] (f : M × M₂ →ₗ[R] M₃), (f ∘ₗ LinearMap.inl R M M₂).coprod (f ∘ₗ LinearMap.inr R M M₂) = f |
Std.DHashMap.Internal.Raw.fold_cons_key | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {l : Std.DHashMap.Raw α β} {acc : List α},
Std.DHashMap.Raw.fold (fun acc k x => k :: acc) acc l =
Std.Internal.List.keys (Std.DHashMap.Internal.toListModel l.buckets).reverse ++ acc |
_private.Mathlib.Util.FormatTable.0.formatTable.match_1 | Mathlib.Util.FormatTable | (motive : ℕ → Alignment → Sort u_1) →
(w : ℕ) →
(a : Alignment) →
((x : Alignment) → motive 0 x) →
((x : Alignment) → motive 1 x) →
((n : ℕ) → motive n.succ.succ Alignment.left) →
((n : ℕ) → motive n.succ.succ Alignment.right) →
((n : ℕ) → motive n.succ.succ Alignment.center) → motive w a |
_private.Lean.Compiler.IR.SimpleGroundExpr.0.Lean.IR.compileToSimpleGroundExpr.compileSetChain._sparseCasesOn_4 | Lean.Compiler.IR.SimpleGroundExpr | {motive : Lean.IR.SimpleGroundValue✝ → Sort u} →
(t : Lean.IR.SimpleGroundValue✝¹) →
((val : USize) → motive (Lean.IR.SimpleGroundValue.usize✝ val)) →
(Nat.hasNotBit 32 (Lean.IR.SimpleGroundValue.ctorIdx✝ t) → motive t) → motive t |
Nat.addUnits_eq_zero | Mathlib.Algebra.Group.Nat.Units | ∀ (u : AddUnits ℕ), u = 0 |
Filter.EventuallyLE.measure_le | Mathlib.MeasureTheory.OuterMeasure.AE | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {s t : Set α}, s ≤ᵐ[μ] t → μ s ≤ μ t |
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.Context.mk.sizeOf_spec | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | ∀ (f fType : Lean.Expr) (args mvars : Array Lean.Expr) (bInfos : Array Lean.BinderInfo) (forceRegularApp : Bool),
sizeOf
{ f := f, fType := fType, args := args, mvars := mvars, bInfos := bInfos, forceRegularApp := forceRegularApp } =
1 + sizeOf f + sizeOf fType + sizeOf args + sizeOf mvars + sizeOf bInfos + sizeOf forceRegularApp |
Padic.coe_one | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)], ↑1 = 1 |
LocallyConstant.comapRingHom._proof_1 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {Z : Type u_1}
[inst_2 : Semiring Z] (f : C(X, Y)), (↑(LocallyConstant.comapAddMonoidHom f)).toFun 0 = 0 |
AlgebraicGeometry.Scheme.LocalRepresentability.yonedaGluedToSheaf_app_toGlued | Mathlib.AlgebraicGeometry.Sites.Representability | ∀ {F : CategoryTheory.Sheaf AlgebraicGeometry.Scheme.zariskiTopology (Type u)} {ι : Type u}
{X : ι → AlgebraicGeometry.Scheme} {f : (i : ι) → CategoryTheory.yoneda.obj (X i) ⟶ F.val}
(hf : ∀ (i : ι), AlgebraicGeometry.IsOpenImmersion.presheaf (f i)) {i : ι},
(AlgebraicGeometry.Scheme.LocalRepresentability.yonedaGluedToSheaf hf).val.app (Opposite.op (X i))
(AlgebraicGeometry.Scheme.LocalRepresentability.toGlued hf i) =
CategoryTheory.yonedaEquiv (f i) |
fderivPolarCoordSymm._proof_8 | Mathlib.Analysis.SpecialFunctions.PolarCoord | FiniteDimensional ℝ (ℝ × ℝ) |
RingEquiv.nonUnitalSubringCongr | Mathlib.RingTheory.NonUnitalSubring.Basic | {R : Type u} → [inst : NonUnitalRing R] → {s t : NonUnitalSubring R} → s = t → ↥s ≃+* ↥t |
UniqueFactorizationMonoid.radical_mul | Mathlib.RingTheory.Radical | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [inst_1 : NormalizationMonoid M] [inst_2 : UniqueFactorizationMonoid M]
{a b : M},
IsRelPrime a b →
UniqueFactorizationMonoid.radical (a * b) =
UniqueFactorizationMonoid.radical a * UniqueFactorizationMonoid.radical b |
TopologicalSpace.Opens.openPartialHomeomorphSubtypeCoe.eq_1 | Mathlib.Topology.OpenPartialHomeomorph.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] (s : TopologicalSpace.Opens X) (hs : Nonempty ↥s),
s.openPartialHomeomorphSubtypeCoe hs = Topology.IsOpenEmbedding.toOpenPartialHomeomorph Subtype.val ⋯ |
_private.Mathlib.Combinatorics.Enumerative.IncidenceAlgebra.0.IncidenceAlgebra.moebius_inversion_top._simp_1_10 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {M : Type u_4} [inst : AddMonoid M] [IsLeftCancelAdd M] {a b : M}, (a + b = a) = (b = 0) |
Lean.PrettyPrinter.Delaborator.OmissionReason.noConfusionType | Lean.PrettyPrinter.Delaborator.Basic | Sort u → Lean.PrettyPrinter.Delaborator.OmissionReason → Lean.PrettyPrinter.Delaborator.OmissionReason → Sort u |
FinsetFamily._aux_Mathlib_Combinatorics_SetFamily_Compression_UV___unexpand_UV_compression_1 | Mathlib.Combinatorics.SetFamily.Compression.UV | Lean.PrettyPrinter.Unexpander |
Std.ExtDTreeMap.Const.getKeyD_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α (fun x => Unit) cmp} [inst : Std.TransCmp cmp]
{l : List α} {k k' fallback : α},
cmp k k' = Ordering.eq →
k ∉ t →
List.Pairwise (fun a b => ¬cmp a b = Ordering.eq) l →
k ∈ l → (Std.ExtDTreeMap.Const.insertManyIfNewUnit t l).getKeyD k' fallback = k |
RatFunc.instAlgebraOfPolynomial | Mathlib.FieldTheory.RatFunc.Basic | (K : Type u) →
[inst : CommRing K] →
[inst_1 : IsDomain K] →
(R : Type u_1) → [inst_2 : CommSemiring R] → [Algebra R (Polynomial K)] → Algebra R (RatFunc K) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.