name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Equiv.Perm.ext | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {σ τ : Equiv.Perm α}, (∀ (x : α), σ x = τ x) → σ = τ |
Quaternion.normSq_le_zero._simp_1 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] {a : Quaternion R},
(Quaternion.normSq a ≤ 0) = (a = 0) |
Lean.Doc.DocHighlight._sizeOf_1 | Lean.Elab.DocString.Builtin | Lean.Doc.DocHighlight → ℕ |
Rat.natCast_le_cast._simp_1 | Mathlib.Data.Rat.Cast.Order | ∀ {K : Type u_5} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] {m : ℕ} {n : ℚ}, (↑m ≤ ↑n) = (↑m ≤ n) |
ONote._sizeOf_1 | Mathlib.SetTheory.Ordinal.Notation | ONote → ℕ |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.caching.unsafe_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof | {α : Type u_1} → α → UInt64 |
_private.Mathlib.FieldTheory.Separable.0.Polynomial.separable_of_subsingleton._simp_1_2 | Mathlib.FieldTheory.Separable | ∀ {α : Sort u_1} [Subsingleton α] (x y : α), (x = y) = True |
Fin.Value.mk.injEq | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | ∀ (n : ℕ) (value : Fin n) (n_1 : ℕ) (value_1 : Fin n_1),
({ n := n, value := value } = { n := n_1, value := value_1 }) = (n = n_1 ∧ value ≍ value_1) |
NonemptyFinLinOrd._sizeOf_1 | Mathlib.Order.Category.NonemptyFinLinOrd | NonemptyFinLinOrd → ℕ |
Equiv.vadd | Mathlib.Algebra.Group.TransferInstance | (M : Type u_1) → {α : Type u_2} → {β : Type u_3} → α ≃ β → [VAdd M β] → VAdd M α |
CategoryTheory.ShortComplex.homologyι_naturality | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology],
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.homologyMap φ) S₂.homologyι =
CategoryTheory.CategoryStruct.comp S₁.homologyι (CategoryTheory.ShortComplex.opcyclesMap φ) |
Lean.JsonRpc.MessageDirection.toCtorIdx | Lean.Data.JsonRpc | Lean.JsonRpc.MessageDirection → ℕ |
isCoprime_mul_units_right | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {u v : R},
IsUnit u → IsUnit v → ∀ (y z : R), IsCoprime (y * u) (z * v) ↔ IsCoprime y z |
Path.Homotopy.reflTransSymmAux_mem_I | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ (x : ↑unitInterval × ↑unitInterval), Path.Homotopy.reflTransSymmAux x ∈ unitInterval |
IsStrictOrder.toIsTrans | Mathlib.Order.Defs.Unbundled | ∀ {α : Sort u_1} {r : α → α → Prop} [self : IsStrictOrder α r], IsTrans α r |
_private.Mathlib.Analysis.Complex.Polynomial.GaussLucas.0.Polynomial.eq_centerMass_of_eval_derivative_eq_zero._simp_1_12 | Mathlib.Analysis.Complex.Polynomial.GaussLucas | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False |
Set.powersetCard.addAction_faithful | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ {α : Type u_2} [inst : DecidableEq α] {G : Type u_3} [inst_1 : AddGroup G] [inst_2 : AddAction G α] {n : ℕ},
1 ≤ n → ↑n < ENat.card α → ∀ {g : G}, AddAction.toPerm g = 1 ↔ AddAction.toPerm g = 1 |
_private.Mathlib.RingTheory.MvPowerSeries.LinearTopology.0.MvPowerSeries.LinearTopology.isTopologicallyNilpotent_of_constantCoeff._simp_1_5 | Mathlib.RingTheory.MvPowerSeries.LinearTopology | ∀ {σ : Type u_1} {R : Type u_2} {S : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (n : σ →₀ ℕ)
(φ : MvPowerSeries σ R), f ((MvPowerSeries.coeff n) φ) = (MvPowerSeries.coeff n) ((MvPowerSeries.map f) φ) |
Set.mapsTo_id | Mathlib.Data.Set.Function | ∀ {α : Type u_1} (s : Set α), Set.MapsTo id s s |
AlgebraicGeometry.Scheme.Cover.ColimitGluingData.isColimitGluedCocone._proof_6 | Mathlib.AlgebraicGeometry.ColimitsOver | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [inst : P.IsStableUnderBaseChange]
[inst_1 : P.IsMultiplicative] {S : AlgebraicGeometry.Scheme} {J : Type u_5}
[inst_2 : CategoryTheory.Category.{u_4, u_5} J] {D : CategoryTheory.Functor J (P.Over ⊤ S)} {𝒰 : S.OpenCover}
[inst_3 : CategoryTheory.Category.{u_3, u_1} 𝒰.I₀] [inst_4 : AlgebraicGeometry.Scheme.Cover.LocallyDirected 𝒰]
(d : AlgebraicGeometry.Scheme.Cover.ColimitGluingData D 𝒰)
[inst_5 :
∀ {i j : 𝒰.I₀} (hij : i ⟶ j),
CategoryTheory.Limits.PreservesColimitsOfShape J
(CategoryTheory.MorphismProperty.Over.pullback P ⊤ (AlgebraicGeometry.Scheme.Cover.trans 𝒰 hij))]
[inst_6 : Quiver.IsThin 𝒰.I₀] [inst_7 : Small.{u_2, u_1} 𝒰.I₀] [inst_8 : AlgebraicGeometry.IsZariskiLocalAtTarget P]
(s : CategoryTheory.Limits.Cocone D) (i : d.relativeGluingData.cover.I₀),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
((d.isColimit i).desc ((CategoryTheory.MorphismProperty.Over.pullback P ⊤ (𝒰.f i)).mapCocone s)).left
(CategoryTheory.Limits.pullback.fst s.pt.hom (𝒰.f i)))
s.pt.hom =
CategoryTheory.CategoryStruct.comp (d.relativeGluingData.cover.f i) d.glued.hom |
Std.Time.Week.Offset.toHours | Std.Time.Date.Unit.Week | Std.Time.Week.Offset → Std.Time.Hour.Offset |
CategoryTheory.Lax.LaxTrans.id | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] → (F : CategoryTheory.LaxFunctor B C) → CategoryTheory.Lax.LaxTrans F F |
Lean.Elab.Modifiers.mk | Lean.Elab.DeclModifiers | Lean.TSyntax `Lean.Parser.Command.declModifiers →
Option (Lean.TSyntax `Lean.Parser.Command.docComment × Bool) →
Lean.Elab.Visibility →
Bool → Lean.Elab.ComputeKind → Lean.Elab.RecKind → Bool → Array Lean.Elab.Attribute → Lean.Elab.Modifiers |
TensorProduct.leftHasSMul | Mathlib.LinearAlgebra.TensorProduct.Defs | {R : Type u_1} →
{R' : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : Monoid R'] →
{M : Type u_7} →
{N : Type u_8} →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid N] →
[inst_4 : DistribMulAction R' M] →
[inst_5 : Module R M] → [inst_6 : Module R N] → [SMulCommClass R R' M] → SMul R' (TensorProduct R M N) |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.PreprocessKind.mvarsOutputParams.sizeOf_spec | Lean.Meta.SynthInstance | sizeOf Lean.Meta.PreprocessKind.mvarsOutputParams✝ = 1 |
TestFunctionClass.noConfusionType | Mathlib.Analysis.Distribution.TestFunction | Sort u →
{B : Type u_6} →
{E : Type u_7} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
{Ω : TopologicalSpace.Opens E} →
{F : Type u_8} →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NormedSpace ℝ F] →
{n : ℕ∞} →
TestFunctionClass B Ω F n →
{B' : Type u_6} →
{E' : Type u_7} →
[inst' : NormedAddCommGroup E'] →
[inst'_1 : NormedSpace ℝ E'] →
{Ω' : TopologicalSpace.Opens E'} →
{F' : Type u_8} →
[inst'_2 : NormedAddCommGroup F'] →
[inst'_3 : NormedSpace ℝ F'] → {n' : ℕ∞} → TestFunctionClass B' Ω' F' n' → Sort u |
CategoryTheory.ShortComplex.Homotopy.refl_h₁ | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂), (CategoryTheory.ShortComplex.Homotopy.refl φ).h₁ = 0 |
DirectLimit.instAddMonoid._proof_6 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : (i : ι) → AddMonoid (G i)] [∀ (i j : ι) (h : i ≤ j), AddMonoidHomClass (T h) (G i) (G j)] (n : ℕ)
(x x_1 : ι) (x_2 : x ≤ x_1) (x_3 : G x), (f x x_1 x_2) (n • x_3) = n • (f x x_1 x_2) x_3 |
Asymptotics.IsLittleO.sub | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {F : Type u_4} {E' : Type u_6} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {g : α → F}
{l : Filter α} {f₁ f₂ : α → E'}, f₁ =o[l] g → f₂ =o[l] g → (fun x => f₁ x - f₂ x) =o[l] g |
Int.sub_lt_sub_right_iff._simp_1 | Init.Data.Int.Order | ∀ {a b c : ℤ}, (a - c < b - c) = (a < b) |
Lean.Grind.NoopConfig.noConfusionType | Init.Grind.Config | Sort u → Lean.Grind.NoopConfig → Lean.Grind.NoopConfig → Sort u |
_private.Lean.Compiler.LCNF.Simp.DefaultAlt.0.Lean.Compiler.LCNF.Simp.addDefaultAlt.match_7 | Lean.Compiler.LCNF.Simp.DefaultAlt | (motive : MProd (Array (Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.pure)) Bool → Sort u_1) →
(r : MProd (Array (Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.pure)) Bool) →
((altsNew : Array (Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.pure)) →
(first : Bool) → motive ⟨altsNew, first⟩) →
motive r |
_private.Lean.Meta.Tactic.Simp.Types.0.Lean.Meta.Simp.tryAutoCongrTheorem?._proof_1 | Lean.Meta.Tactic.Simp.Types | ∀ (__do_lift : Lean.Meta.FunInfo) (config : Lean.Meta.Simp.Config)
(r :
MProd (Subarray Lean.Meta.CongrArgKind)
(MProd (Array Lean.Meta.Simp.Result) (MProd (Array Lean.Expr) (MProd Bool (MProd Bool (MProd ℕ Bool)))))),
config.ground = true ∧ r.snd.snd.snd.snd.snd.fst < __do_lift.paramInfo.size →
r.snd.snd.snd.snd.snd.fst < __do_lift.paramInfo.size |
_private.Mathlib.Order.Defs.PartialOrder.0.le_antisymm_iff.match_1_1 | Mathlib.Order.Defs.PartialOrder | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α} (motive : a ≤ b ∧ b ≤ a → Prop) (x : a ≤ b ∧ b ≤ a),
(∀ (h1 : a ≤ b) (h2 : b ≤ a), motive ⋯) → motive x |
Digraph.toSimpleGraphStrict._proof_1 | Mathlib.Combinatorics.Digraph.Orientation | ∀ {V : Type u_1} (G : Digraph V) (x x_1 : V), x ≠ x_1 ∧ G.Adj x x_1 ∧ G.Adj x_1 x → x_1 ≠ x ∧ G.Adj x_1 x ∧ G.Adj x x_1 |
_private.Mathlib.AlgebraicGeometry.Morphisms.RingHomProperties.0.AlgebraicGeometry.affineLocally_iff_forall_isAffineOpen._simp_1_1 | Mathlib.AlgebraicGeometry.Morphisms.RingHomProperties | ∀ (P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop) {X Y : AlgebraicGeometry.Scheme}
(f : X ⟶ Y),
AlgebraicGeometry.affineLocally (fun {R S} [CommRing R] [CommRing S] => P) f =
∀ (U : ↑Y.affineOpens) (V : ↑X.affineOpens) (e : ↑V ≤ (TopologicalSpace.Opens.map f.base).obj ↑U),
P (CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.Hom.appLE f (↑U) (↑V) e)) |
Set.singleton_subset_singleton._gcongr_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u} {a b : α}, a = b → {a} ⊆ {b} |
USize.toNat_ofFin | Init.Data.UInt.Lemmas | ∀ (x : Fin USize.size), (USize.ofFin x).toNat = ↑x |
_private.Mathlib.GroupTheory.GroupAction.Blocks.0.MulAction.IsBlock.of_subset._simp_1_3 | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : DivisionMonoid G] (a b : G), b⁻¹ * a⁻¹ = (a * b)⁻¹ |
Orientation.oangle_sign_sub_smul_left | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x y : V) (r : ℝ), (o.oangle (x - r • y) y).sign = (o.oangle x y).sign |
_private.Batteries.Data.Random.MersenneTwister.0.Batteries.Random.MersenneTwister.Config.lMask | Batteries.Data.Random.MersenneTwister | (cfg : Batteries.Random.MersenneTwister.Config) → BitVec cfg.wordSize |
Lean.Environment.imports | Lean.Environment | Lean.Environment → Array Lean.Import |
Std.Internal.IO.Async.System.GroupInfo.groupName | Std.Internal.Async.System | Std.Internal.IO.Async.System.GroupInfo → String |
Std.Internal.List.maxKey!_insertEntryIfNew | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
[inst_4 : Inhabited α] {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ {k : α} {v : β k},
Std.Internal.List.maxKey! (Std.Internal.List.insertEntryIfNew k v l) =
(Std.Internal.List.maxKey? l).elim k fun k' => if compare k' k = Ordering.lt then k else k' |
_private.Lean.Compiler.LCNF.Simp.SimpValue.0.Lean.Compiler.LCNF.Simp.simpCtorDiscr?.match_6 | Lean.Compiler.LCNF.Simp.SimpValue | (motive : Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure → Sort u_1) →
(e : Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure) →
((declName : Lean.Name) →
(us : List Lean.Level) →
(args : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) →
motive (Lean.Compiler.LCNF.LetValue.const declName us args ⋯)) →
((x : Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure) → motive x) → motive e |
_private.Mathlib.Algebra.Ring.GeomSum.0.geom_sum₂_mul_of_le._simp_1_1 | Mathlib.Algebra.Ring.GeomSum | ∀ {n m : ℕ}, (m ∈ Finset.range n) = (m < n) |
Mathlib.Tactic.FieldSimp.Sign.mul.match_1 | Mathlib.Tactic.FieldSimp.Lemmas | {v : Lean.Level} →
{M : Q(Type v)} →
(motive : Mathlib.Tactic.FieldSimp.Sign M → Mathlib.Tactic.FieldSimp.Sign M → Sort u_1) →
(g₁ g₂ : Mathlib.Tactic.FieldSimp.Sign M) →
(Unit → motive Mathlib.Tactic.FieldSimp.Sign.plus Mathlib.Tactic.FieldSimp.Sign.plus) →
((i : Q(Field «$M»)) → motive Mathlib.Tactic.FieldSimp.Sign.plus (Mathlib.Tactic.FieldSimp.Sign.minus i)) →
((i : Q(Field «$M»)) → motive (Mathlib.Tactic.FieldSimp.Sign.minus i) Mathlib.Tactic.FieldSimp.Sign.plus) →
((iM iM_1 : Q(Field «$M»)) →
motive (Mathlib.Tactic.FieldSimp.Sign.minus iM) (Mathlib.Tactic.FieldSimp.Sign.minus iM_1)) →
motive g₁ g₂ |
Std.DTreeMap.minKeyD_le_minKeyD_erase | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k : α},
(t.erase k).isEmpty = false → ∀ {fallback : α}, (cmp (t.minKeyD fallback) ((t.erase k).minKeyD fallback)).isLE = true |
Std.DHashMap.Internal.Raw.WFImp.mk._flat_ctor | Std.Data.DHashMap.Internal.Defs | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β},
Std.DHashMap.Internal.IsHashSelf m.buckets →
m.size = (Std.DHashMap.Internal.toListModel m.buckets).length →
Std.Internal.List.DistinctKeys (Std.DHashMap.Internal.toListModel m.buckets) → Std.DHashMap.Internal.Raw.WFImp m |
CategoryTheory.Limits.SequentialProduct.functorMap_commSq_succ._proof_6 | Mathlib.CategoryTheory.Limits.Shapes.SequentialProduct | ∀ (n : ℕ), n < n + 1 |
HasDerivWithinAt.clog | Mathlib.Analysis.SpecialFunctions.Complex.LogDeriv | ∀ {f : ℂ → ℂ} {f' x : ℂ} {s : Set ℂ},
HasDerivWithinAt f f' s x → f x ∈ Complex.slitPlane → HasDerivWithinAt (fun t => Complex.log (f t)) (f' / f x) s x |
LinearEquiv.symmEquiv_apply_symm_apply | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_S_M₂ : Module S M₂}
{σ : R →+* S} {σ' : S →+* R} {re₁ : RingHomInvPair σ σ'} {re₂ : RingHomInvPair σ' σ} (e : M ≃ₛₗ[σ] M₂) (a : M),
(LinearEquiv.symmEquiv e).symm a = e a |
List.alternatingProd._sunfold | Mathlib.Algebra.BigOperators.Group.List.Defs | {G : Type u_4} → [One G] → [Mul G] → [Inv G] → List G → G |
QuotientAddGroup.induction_on | Mathlib.GroupTheory.Coset.Defs | ∀ {α : Type u_1} [inst : AddGroup α] {s : AddSubgroup α} {C : α ⧸ s → Prop} (x : α ⧸ s), (∀ (z : α), C ↑z) → C x |
ProbabilityTheory.Kernel.compProd_of_not_isSFiniteKernel_left | Mathlib.Probability.Kernel.Composition.CompProd | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) (η : ProbabilityTheory.Kernel (α × β) γ),
¬ProbabilityTheory.IsSFiniteKernel κ → κ.compProd η = 0 |
_private.Mathlib.Topology.Bornology.Absorbs.0.absorbs_inter._simp_1_1 | Mathlib.Topology.Bornology.Absorbs | ∀ {G₀ : Type u_1} {α : Type u_2} [inst : GroupWithZero G₀] [inst_1 : Bornology G₀] [inst_2 : MulAction G₀ α]
{s t : Set α}, Absorbs G₀ s t = ∀ᶠ (c : G₀) in Bornology.cobounded G₀, Set.MapsTo (fun x => c⁻¹ • x) t s |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Finset.sum_Ico_Ico_comm._proof_1_4 | Mathlib.Algebra.BigOperators.Intervals | ∀ (a b a_1 b_1 : ℕ), (a ≤ a_1 ∧ a_1 < b) ∧ a_1 ≤ b_1 ∧ b_1 < b → (a ≤ b_1 ∧ b_1 < b) ∧ a ≤ a_1 ∧ a_1 < b_1 + 1 |
_private.Lean.Meta.Tactic.Cbv.TheoremsLookup.0.Lean.Meta.Sym.Simp.Theorems.insertMany | Lean.Meta.Tactic.Cbv.TheoremsLookup | Lean.Meta.Sym.Simp.Theorems → Array Lean.Meta.Sym.Simp.Theorem → Lean.Meta.Sym.Simp.Theorems |
PFun.fixInduction'._proof_2 | Mathlib.Data.PFun | ∀ {α : Type u_1} {β : Type u_2} {f : α →. β ⊕ α} {b : β} (a' : α),
b ∈ f.fix a' → ∀ (b' : β), Sum.inl b' ∈ f a' → Sum.inl b ∈ f a' |
isOpen_interior._simp_1 | Mathlib.Topology.Closure | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsOpen (interior s) = True |
Order.Ideal.instInfSet | Mathlib.Order.Ideal | {P : Type u_1} → [inst : SemilatticeSup P] → [OrderBot P] → InfSet (Order.Ideal P) |
String.Slice.Pattern.Model.ForwardSliceSearcher.matchesAt_iff_splits | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {pat s : String.Slice} {pos : s.Pos},
pat.isEmpty = false → (String.Slice.Pattern.Model.MatchesAt pat pos ↔ ∃ t₁ t₂, pos.Splits t₁ (pat.copy ++ t₂)) |
Plausible.InjectiveFunction.shrink._proof_1 | Mathlib.Testing.Plausible.Functions | ∀ {α : Type} (xs : List ((_ : α) × α)),
(List.map Sigma.fst xs).Perm (List.map Sigma.snd xs) →
(List.map Sigma.snd xs).Nodup → (List.map Sigma.fst xs).Perm (List.map Sigma.snd xs) ∧ (List.map Sigma.snd xs).Nodup |
Lean.Parser.Tactic.case' | Init.Tactics | Lean.ParserDescr |
CategoryTheory.Coverage.mk.noConfusion | Mathlib.CategoryTheory.Sites.Coverage | {C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{P : Sort u} →
{toPrecoverage : CategoryTheory.Precoverage C} →
{pullback :
∀ ⦃X Y : C⦄ (f : Y ⟶ X),
∀ S ∈ toPrecoverage.coverings X, ∃ T ∈ toPrecoverage.coverings Y, T.FactorsThruAlong S f} →
{toPrecoverage' : CategoryTheory.Precoverage C} →
{pullback' :
∀ ⦃X Y : C⦄ (f : Y ⟶ X),
∀ S ∈ toPrecoverage'.coverings X, ∃ T ∈ toPrecoverage'.coverings Y, T.FactorsThruAlong S f} →
{ toPrecoverage := toPrecoverage, pullback := pullback } =
{ toPrecoverage := toPrecoverage', pullback := pullback' } →
(toPrecoverage ≍ toPrecoverage' → P) → P |
CategoryTheory.instHasLiftingPropertySnd | Mathlib.CategoryTheory.LiftingProperties.Limits | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {Y Z W : C} {g : Z ⟶ W} {t : Y ⟶ W}
[inst_1 : CategoryTheory.Limits.HasPullback g t] {T₁ T₂ : C} (p : T₁ ⟶ T₂) [CategoryTheory.HasLiftingProperty p g],
CategoryTheory.HasLiftingProperty p (CategoryTheory.Limits.pullback.snd g t) |
Subsemiring.unop_eq_bot._simp_1 | Mathlib.Algebra.Ring.Subsemiring.MulOpposite | ∀ {R : Type u_2} [inst : NonAssocSemiring R] {S : Subsemiring Rᵐᵒᵖ}, (S.unop = ⊥) = (S = ⊥) |
MeasureTheory.Measure.addHaarScalarFactor_smul_congr | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {G : Type u_1} {A : Type u_2} [inst : Group G] [inst_1 : AddCommGroup A] [inst_2 : DistribMulAction G A]
[inst_3 : MeasurableSpace A] [inst_4 : TopologicalSpace A] [inst_5 : BorelSpace A] [inst_6 : IsTopologicalAddGroup A]
[LocallyCompactSpace A] [inst_8 : ContinuousConstSMul G A] (μ : MeasureTheory.Measure A) {ν : MeasureTheory.Measure A}
[inst_9 : μ.IsAddHaarMeasure] [inst_10 : ν.IsAddHaarMeasure] (g : Gᵈᵐᵃ),
μ.addHaarScalarFactor (g • μ) = ν.addHaarScalarFactor (g • ν) |
Aesop.ForwardRuleMatches.noConfusionType | Aesop.Tree.Data.ForwardRuleMatches | Sort u → Aesop.ForwardRuleMatches → Aesop.ForwardRuleMatches → Sort u |
DFinsupp.instLocallyFiniteOrder | Mathlib.Data.DFinsupp.Interval | {ι : Type u_1} →
{α : ι → Type u_2} →
[DecidableEq ι] →
[(i : ι) → DecidableEq (α i)] →
[inst : (i : ι) → PartialOrder (α i)] →
[inst_1 : (i : ι) → Zero (α i)] → [(i : ι) → LocallyFiniteOrder (α i)] → LocallyFiniteOrder (Π₀ (i : ι), α i) |
NonemptyFinLinOrd.mk | Mathlib.Order.Category.NonemptyFinLinOrd | (toLinOrd : LinOrd) → [nonempty : Nonempty ↑toLinOrd] → [fintype : Fintype ↑toLinOrd] → NonemptyFinLinOrd |
_private.Init.Data.Format.Basic.0.Std.Format.WorkGroup | Init.Data.Format.Basic | Type |
instMonoidWithConvMatrix._proof_4 | Mathlib.LinearAlgebra.Matrix.WithConv | ∀ {α : Type u_1} {m : Type u_3} {n : Type u_2} [inst : Monoid α] (a : WithConv (Matrix m n α)), a * 1 = a |
Lean.Meta.DefEqCacheKind | Lean.Meta.ExprDefEq | Type |
Lean.Elab.Term.Quotation.MatchResult.noConfusion | Lean.Elab.Quotation | {P : Sort u} →
{t t' : Lean.Elab.Term.Quotation.MatchResult} → t = t' → Lean.Elab.Term.Quotation.MatchResult.noConfusionType P t t' |
Finset.instFintypeSubtypeMemSubgroupInvMulSubgroup._simp_2 | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Mul α] (s t : Finset α), ↑s * ↑t = ↑(s * t) |
MulRingSeminormClass.toMonoidHomClass | Mathlib.Algebra.Order.Hom.Basic | ∀ {F : Type u_7} {α : outParam (Type u_8)} {β : outParam (Type u_9)} {inst : NonAssocRing α} {inst_1 : Semiring β}
{inst_2 : PartialOrder β} {inst_3 : FunLike F α β} [self : MulRingSeminormClass F α β], MonoidHomClass F α β |
_private.Lean.Elab.CheckTactic.0.Lean.Elab.CheckTactic.elabCheckTactic.match_8 | Lean.Elab.CheckTactic | (motive : List Lean.MVarId × Lean.Elab.Term.State → Sort u_1) →
(__discr : List Lean.MVarId × Lean.Elab.Term.State) →
((goals : List Lean.MVarId) → (snd : Lean.Elab.Term.State) → motive (goals, snd)) → motive __discr |
HomologicalComplex.Hom.isIso_of_components | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ C₂ : HomologicalComplex V c}
(f : C₁ ⟶ C₂) [∀ (n : ι), CategoryTheory.IsIso (f.f n)], CategoryTheory.IsIso f |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.NormalizePattern.Context.symPrios | Lean.Meta.Tactic.Grind.EMatchTheorem | Lean.Meta.Grind.NormalizePattern.Context✝ → Lean.Meta.Grind.SymbolPriorities |
exists_seq_strictAnti_strictMono_tendsto | Mathlib.Topology.Order.IsLUB | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [DenselyOrdered α]
[FirstCountableTopology α] {x y : α},
x < y →
∃ u v,
StrictAnti u ∧
StrictMono v ∧
(∀ (k : ℕ), u k ∈ Set.Ioo x y) ∧
(∀ (l : ℕ), v l ∈ Set.Ioo x y) ∧
(∀ (k l : ℕ), u k < v l) ∧ Filter.Tendsto u Filter.atTop (nhds x) ∧ Filter.Tendsto v Filter.atTop (nhds y) |
Asymptotics.IsLittleO.forall_isBigOWith | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F} {l : Filter α},
f =o[l] g → ∀ ⦃c : ℝ⦄, 0 < c → Asymptotics.IsBigOWith c l f g |
MvPowerSeries.lexOrder_eq_top_iff_eq_zero._simp_1 | Mathlib.RingTheory.MvPowerSeries.LexOrder | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] [inst_1 : LinearOrder σ] [inst_2 : WellFoundedGT σ]
(φ : MvPowerSeries σ R), (φ.lexOrder = ⊤) = (φ = 0) |
ContinuousMap.instNormedCommRing._proof_2 | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} [inst : TopologicalSpace α] {R : Type u_2} [inst_1 : NormedCommRing R] (a b : C(α, R)), a * b = b * a |
SSet.Subcomplex.N.mk | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplicesSubcomplex | {X : SSet} →
{A : X.Subcomplex} →
{n : ℕ} →
(x : X.obj (Opposite.op (SimplexCategory.mk n))) →
x ∈ X.nonDegenerate n → x ∉ A.obj (Opposite.op (SimplexCategory.mk n)) → A.N |
em | Mathlib.Logic.Basic | ∀ (p : Prop), p ∨ ¬p |
PolynomialLaw.instAddCommMonoid._proof_4 | Mathlib.RingTheory.PolynomialLaw.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (f : M →ₚₗ[R] N), ↑0 • f = 0 |
IntermediateField.LinearDisjoint.adjoin_rank_eq_rank_left_of_isAlgebraic | Mathlib.FieldTheory.LinearDisjoint | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A : IntermediateField F E}
{L : Type w} [inst_3 : Field L] [inst_4 : Algebra F L] [inst_5 : Algebra L E] [inst_6 : IsScalarTower F L E],
A.LinearDisjoint L →
Algebra.IsAlgebraic F ↥A ∨ Algebra.IsAlgebraic F L →
Module.rank L ↥(IntermediateField.adjoin L ↑A) = Module.rank F ↥A |
TwoSidedIdeal.opOrderIso_apply | Mathlib.RingTheory.TwoSidedIdeal.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (I : TwoSidedIdeal R), TwoSidedIdeal.opOrderIso I = I.op |
_private.Mathlib.MeasureTheory.Measure.WithDensity.0.MeasureTheory.withDensity_apply_eq_zero'._simp_1_4 | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) |
Mathlib.Meta.NormNum.proveJacobiSym | Mathlib.Tactic.NormNum.LegendreSymbol | (ea : Q(ℤ)) → (eb : Q(ℕ)) → (er : Q(ℤ)) × Q(jacobiSym «$ea» «$eb» = «$er») |
Std.ExtTreeSet.insertMany_nil | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp], t.insertMany [] = t |
Ideal.count_associates_eq | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] {a a₀ x : R} {n : ℕ},
Prime x →
¬x ∣ a → a₀ = x ^ n * a → (Associates.mk (Ideal.span {x})).count (Associates.mk (Ideal.span {a₀})).factors = n |
CategoryTheory.Kleisli.Adjunction.adj._proof_4 | Mathlib.CategoryTheory.Monad.Kleisli | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (T : CategoryTheory.Monad C) {X : C}
{Y Y' : CategoryTheory.Kleisli T} (f : (CategoryTheory.Kleisli.Adjunction.toKleisli T).obj X ⟶ Y) (g : Y ⟶ Y'),
{ toFun := fun f => f.of, invFun := fun f => { of := f }, left_inv := ⋯, right_inv := ⋯ }
(CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp
({ toFun := fun f => f.of, invFun := fun f => { of := f }, left_inv := ⋯, right_inv := ⋯ } f)
((CategoryTheory.Kleisli.Adjunction.fromKleisli T).map g) |
Std.DHashMap.mem_of_mem_filter | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [EquivBEq α] [LawfulHashable α]
{f : (a : α) → β a → Bool} {k : α}, k ∈ Std.DHashMap.filter f m → k ∈ m |
Std.DTreeMap.Raw.get?_alter | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp],
t.WF →
∀ {k k' : α} {f : Option (β k) → Option (β k)},
(t.alter k f).get? k' = if h : cmp k k' = Ordering.eq then cast ⋯ (f (t.get? k)) else t.get? k' |
ULift.mulAction._proof_1 | Mathlib.Algebra.Module.ULift | ∀ {R : Type u_2} {M : Type u_3} [inst : Monoid R] [inst_1 : MulAction R M] (x x_1 : ULift.{u_1, u_2} R) (b : M),
(x.down * x_1.down) • b = x.down • x_1.down • b |
Std.DTreeMap.Internal.Impl.Const.getD_diff_of_contains_eq_false_right | 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 =
Std.DTreeMap.Internal.Impl.Const.getD m₁ k fallback |
AddSubgroup.mk_le_mk._simp_1 | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] {s t : AddSubmonoid G} (h_neg : ∀ {x : G}, x ∈ s.carrier → -x ∈ s.carrier)
(h_neg' : ∀ {x : G}, x ∈ t.carrier → -x ∈ t.carrier),
({ toAddSubmonoid := s, neg_mem' := h_neg } ≤ { toAddSubmonoid := t, neg_mem' := h_neg' }) = (s ≤ t) |
EReal.induction₂_symm | Mathlib.Data.EReal.Basic | ∀ {P : EReal → EReal → Prop},
(∀ {x y : EReal}, P x y → P y x) →
P ⊤ ⊤ →
(∀ (x : ℝ), 0 < x → P ⊤ ↑x) →
P ⊤ 0 →
(∀ x < 0, P ⊤ ↑x) →
P ⊤ ⊥ →
(∀ (x : ℝ), 0 < x → P ↑x ⊥) →
(∀ (x y : ℝ), P ↑x ↑y) → P 0 ⊥ → (∀ x < 0, P ↑x ⊥) → P ⊥ ⊥ → ∀ (x y : EReal), P x y |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.