name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Submodule.submodule_torsionBy_orderIso._proof_5 | Mathlib.Algebra.Module.Torsion.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M], IsScalarTower R R M |
_private.Mathlib.Tactic.Module.0.Mathlib.Tactic.Module.reduceCoefficientwise.match_9 | Mathlib.Tactic.Module | {u v : Lean.Level} →
{M : Q(Type v)} →
{R : Q(Type u)} →
{x : Q(AddCommMonoid «$M»)} →
{x_1 : Q(Semiring «$R»)} →
(iRM : Q(Module «$R» «$M»)) →
(l₁ : Mathlib.Tactic.Module.qNF R M) →
(L₂ : Mathlib.Tactic.Module.NF (Q(«$R») × Q(«$M»)) ℕ) →
(motive :
(List Lean.MVarId ×
let a := Mathlib.Tactic.Module.qNF.toNF L₂;
let a_1 := l₁.toNF;
Q(Mathlib.Tactic.Module.NF.eval unknown_1 = Mathlib.Tactic.Module.NF.eval unknown_2)) →
Sort u_1) →
(__discr :
List Lean.MVarId ×
let a := Mathlib.Tactic.Module.qNF.toNF L₂;
let a_1 := l₁.toNF;
Q(Mathlib.Tactic.Module.NF.eval unknown_1 = Mathlib.Tactic.Module.NF.eval unknown_2)) →
((mvars : List Lean.MVarId) →
(pf :
let a := Mathlib.Tactic.Module.qNF.toNF L₂;
let a_1 := l₁.toNF;
Q(Mathlib.Tactic.Module.NF.eval unknown_1 = Mathlib.Tactic.Module.NF.eval unknown_2)) →
motive (mvars, pf)) →
motive __discr |
Std.DTreeMap.Internal.Const.toList_ric | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {β : Type v} [inst : Ord α] [Std.TransOrd α] (t : Std.DTreeMap.Internal.Impl α fun x => β),
t.Ordered →
∀ (bound : α),
Std.Slice.toList (Std.Ric.Sliceable.mkSlice t *...=bound) =
List.filter (fun e => (compare e.1 bound).isLE) (Std.DTreeMap.Internal.Impl.Const.toList t) |
Lean.Elab.Command.elabReduce._regBuiltin.Lean.Elab.Command.elabReduce.declRange_3 | Lean.Elab.BuiltinCommand | IO Unit |
CategoryTheory.Limits.CokernelCofork.π_mapOfIsColimit | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
{f : X ⟶ Y} {X' Y' : C} {f' : X' ⟶ Y'} {cc : CategoryTheory.Limits.CokernelCofork f}
(hf : CategoryTheory.Limits.IsColimit cc) (cc' : CategoryTheory.Limits.CokernelCofork f')
(φ : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk f'),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofork.π cc)
(CategoryTheory.Limits.CokernelCofork.mapOfIsColimit hf cc' φ) =
CategoryTheory.CategoryStruct.comp φ.right (CategoryTheory.Limits.Cofork.π cc') |
Std.DTreeMap.Internal.Impl.Equiv.minKeyD_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t₁.WF → t₂.WF → t₁.Equiv t₂ → ∀ {fallback : α}, t₁.minKeyD fallback = t₂.minKeyD fallback |
Std.TreeSet.le_min | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k : α} {he : t.isEmpty = false},
(cmp k (t.min he)).isLE = true ↔ ∀ k' ∈ t, (cmp k k').isLE = true |
Array.replace_extract | Init.Data.Array.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α} {xs : Array α} {i : ℕ},
(xs.extract 0 i).replace a b = (xs.replace a b).extract 0 i |
CategoryTheory.Comma.post | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
{C : Type u₄} →
[inst_3 : CategoryTheory.Category.{v₄, u₄} C] →
(L : CategoryTheory.Functor A T) →
(R : CategoryTheory.Functor B T) →
(F : CategoryTheory.Functor T C) →
CategoryTheory.Functor (CategoryTheory.Comma L R) (CategoryTheory.Comma (L.comp F) (R.comp F)) |
CategoryTheory.CommMon.equivLaxBraidedFunctorPUnit_functor | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C],
CategoryTheory.CommMon.equivLaxBraidedFunctorPUnit.functor =
CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.laxBraidedToCommMon C |
Aesop.GoalUnsafe.rec_6 | Aesop.Tree.Data | {motive_1 : Aesop.GoalUnsafe → Sort u} →
{motive_2 : Aesop.MVarClusterUnsafe → Sort u} →
{motive_3 : Aesop.RappUnsafe → Sort u} →
{motive_4 : Aesop.GoalData Aesop.RappUnsafe Aesop.MVarClusterUnsafe → Sort u} →
{motive_5 : Aesop.MVarClusterData Aesop.GoalUnsafe Aesop.RappUnsafe → Sort u} →
{motive_6 : Aesop.RappData Aesop.GoalUnsafe Aesop.MVarClusterUnsafe → Sort u} →
{motive_7 : Array (IO.Ref Aesop.RappUnsafe) → Sort u} →
{motive_8 : Option (IO.Ref Aesop.RappUnsafe) → Sort u} →
{motive_9 : Array (IO.Ref Aesop.GoalUnsafe) → Sort u} →
{motive_10 : Array (IO.Ref Aesop.MVarClusterUnsafe) → Sort u} →
{motive_11 : List (IO.Ref Aesop.RappUnsafe) → Sort u} →
{motive_12 : List (IO.Ref Aesop.GoalUnsafe) → Sort u} →
{motive_13 : List (IO.Ref Aesop.MVarClusterUnsafe) → Sort u} →
((d : Aesop.GoalData Aesop.RappUnsafe Aesop.MVarClusterUnsafe) →
motive_4 d → motive_1 (Aesop.GoalUnsafe.mk d)) →
((d : Aesop.MVarClusterData Aesop.GoalUnsafe Aesop.RappUnsafe) →
motive_5 d → motive_2 (Aesop.MVarClusterUnsafe.mk d)) →
((d : Aesop.RappData Aesop.GoalUnsafe Aesop.MVarClusterUnsafe) →
motive_6 d → motive_3 (Aesop.RappUnsafe.mk d)) →
((id : Aesop.GoalId) →
(parent : IO.Ref Aesop.MVarClusterUnsafe) →
(children : Array (IO.Ref Aesop.RappUnsafe)) →
(origin : Aesop.GoalOrigin) →
(depth : ℕ) →
(state : Aesop.GoalState) →
(isIrrelevant isForcedUnprovable : Bool) →
(preNormGoal : Lean.MVarId) →
(normalizationState : Aesop.NormalizationState) →
(mvars : Aesop.UnorderedArraySet Lean.MVarId) →
(forwardState : Aesop.ForwardState) →
(forwardRuleMatches : Aesop.ForwardRuleMatches) →
(successProbability : Aesop.Percent) →
(addedInIteration lastExpandedInIteration :
Aesop.Iteration) →
(unsafeRulesSelected : Bool) →
(unsafeQueue : Aesop.UnsafeQueue) →
(failedRapps : Array Aesop.RegularRule) →
motive_7 children →
motive_4
{ id := id, parent := parent,
children := children, origin := origin,
depth := depth, state := state,
isIrrelevant := isIrrelevant,
isForcedUnprovable := isForcedUnprovable,
preNormGoal := preNormGoal,
normalizationState := normalizationState,
mvars := mvars, forwardState := forwardState,
forwardRuleMatches := forwardRuleMatches,
successProbability := successProbability,
addedInIteration := addedInIteration,
lastExpandedInIteration :=
lastExpandedInIteration,
unsafeRulesSelected := unsafeRulesSelected,
unsafeQueue := unsafeQueue,
failedRapps := failedRapps }) →
((parent? : Option (IO.Ref Aesop.RappUnsafe)) →
(goals : Array (IO.Ref Aesop.GoalUnsafe)) →
(isIrrelevant : Bool) →
(state : Aesop.NodeState) →
motive_8 parent? →
motive_9 goals →
motive_5
{ parent? := parent?, goals := goals, isIrrelevant := isIrrelevant,
state := state }) →
((id : Aesop.RappId) →
(parent : IO.Ref Aesop.GoalUnsafe) →
(children : Array (IO.Ref Aesop.MVarClusterUnsafe)) →
(state : Aesop.NodeState) →
(isIrrelevant : Bool) →
(appliedRule : Aesop.RegularRule) →
(scriptSteps? : Option (Array Aesop.Script.LazyStep)) →
(originalSubgoals : Array Lean.MVarId) →
(successProbability : Aesop.Percent) →
(metaState : Lean.Meta.SavedState) →
(introducedMVars assignedMVars :
Aesop.UnorderedArraySet Lean.MVarId) →
motive_10 children →
motive_6
{ id := id, parent := parent, children := children,
state := state, isIrrelevant := isIrrelevant,
appliedRule := appliedRule,
scriptSteps? := scriptSteps?,
originalSubgoals := originalSubgoals,
successProbability := successProbability,
metaState := metaState,
introducedMVars := introducedMVars,
assignedMVars := assignedMVars }) →
((toList : List (IO.Ref Aesop.RappUnsafe)) →
motive_11 toList → motive_7 { toList := toList }) →
motive_8 none →
((val : IO.Ref Aesop.RappUnsafe) → motive_8 (some val)) →
((toList : List (IO.Ref Aesop.GoalUnsafe)) →
motive_12 toList → motive_9 { toList := toList }) →
((toList : List (IO.Ref Aesop.MVarClusterUnsafe)) →
motive_13 toList → motive_10 { toList := toList }) →
motive_11 [] →
((head : IO.Ref Aesop.RappUnsafe) →
(tail : List (IO.Ref Aesop.RappUnsafe)) →
motive_11 tail → motive_11 (head :: tail)) →
motive_12 [] →
((head : IO.Ref Aesop.GoalUnsafe) →
(tail : List (IO.Ref Aesop.GoalUnsafe)) →
motive_12 tail → motive_12 (head :: tail)) →
motive_13 [] →
((head : IO.Ref Aesop.MVarClusterUnsafe) →
(tail : List (IO.Ref Aesop.MVarClusterUnsafe)) →
motive_13 tail → motive_13 (head :: tail)) →
(t : Array (IO.Ref Aesop.GoalUnsafe)) → motive_9 t |
CategoryTheory.TransfiniteCompositionOfShape.F | Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : LinearOrder J] →
[inst_2 : OrderBot J] →
{X Y : C} →
{f : X ⟶ Y} →
[inst_3 : SuccOrder J] →
[inst_4 : WellFoundedLT J] →
CategoryTheory.TransfiniteCompositionOfShape J f → CategoryTheory.Functor J C |
AbsoluteValue.coe_toMonoidWithZeroHom | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {R : Type u_5} {S : Type u_6} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : PartialOrder S]
(abv : AbsoluteValue R S) [inst_3 : IsDomain S] [inst_4 : Nontrivial R], ⇑abv.toMonoidWithZeroHom = ⇑abv |
SchwartzMap.toBoundedContinuousFunctionCLM | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | (𝕜 : Type u_2) →
(E : Type u_5) →
(F : Type u_6) →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NormedSpace ℝ F] →
[inst_4 : RCLike 𝕜] →
[inst_5 : NormedSpace 𝕜 F] →
[inst_6 : SMulCommClass ℝ 𝕜 F] → SchwartzMap E F →L[𝕜] BoundedContinuousFunction E F |
FloatArray.mk | Init.Data.FloatArray.Basic | Array Float → FloatArray |
PartialEquiv.IsImage.of_symm_preimage_eq | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} {e : PartialEquiv α β} {s : Set α} {t : Set β},
e.target ∩ ↑e.symm ⁻¹' s = e.target ∩ t → e.IsImage s t |
KaehlerDifferential.derivationQuotKerTotal | Mathlib.RingTheory.Kaehler.Basic | (R : Type u) →
(S : Type v) →
[inst : CommRing R] →
[inst_1 : CommRing S] → [inst_2 : Algebra R S] → Derivation R S ((S →₀ S) ⧸ KaehlerDifferential.kerTotal R S) |
AlgHom.coeOutAddMonoidHom | Mathlib.Algebra.Algebra.Hom | {R : Type u} →
{A : Type v} →
{B : Type w} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Semiring B] → [inst_3 : Algebra R A] → [inst_4 : Algebra R B] → CoeOut (A →ₐ[R] B) (A →+ B) |
_private.Lean.DocString.Add.0.Lean.parseVersoDocString._sparseCasesOn_1 | Lean.DocString.Add | {motive_1 : Lean.Syntax → Sort u} →
(t : Lean.Syntax) →
((info : Lean.SourceInfo) →
(kind : Lean.SyntaxNodeKind) → (args : Array Lean.Syntax) → motive_1 (Lean.Syntax.node info kind args)) →
(Nat.hasNotBit 2 t.ctorIdx → motive_1 t) → motive_1 t |
Lean.instHashableImport.hash | Lean.Setup | Lean.Import → UInt64 |
MeasureTheory.measure_univ_of_isMulLeftInvariant | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : TopologicalSpace G] [BorelSpace G] [inst_3 : Group G]
[IsTopologicalGroup G] [WeaklyLocallyCompactSpace G] [NoncompactSpace G] (μ : MeasureTheory.Measure G)
[μ.IsOpenPosMeasure] [μ.IsMulLeftInvariant], μ Set.univ = ⊤ |
ContinuousMultilinearMap.seminormedAddCommGroup._proof_1 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : ι → Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι]
(x x_1 : ContinuousMultilinearMap 𝕜 E G), dist x x_1 = dist x x_1 |
Mathlib.Tactic.BicategoryLike.MkEvalComp.ctorIdx | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {m : Type → Type} → Mathlib.Tactic.BicategoryLike.MkEvalComp m → ℕ |
_private.Mathlib.NumberTheory.PythagoreanTriples.0.circleEquivGen._simp_4 | Mathlib.NumberTheory.PythagoreanTriples | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False |
Std.DHashMap.Internal.AssocList.Const.toList_alter | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {a : α} {f : Option β → Option β}
{l : Std.DHashMap.Internal.AssocList α fun x => β},
(Std.DHashMap.Internal.AssocList.Const.alter a f l).toList.Perm (Std.Internal.List.Const.alterKey a f l.toList) |
Std.DHashMap.Raw.instRepr | Std.Data.DHashMap.Raw | {α : Type u} → {β : α → Type v} → [Repr α] → [(a : α) → Repr (β a)] → Repr (Std.DHashMap.Raw α β) |
Std.TreeMap.maxKey!_mem | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.isEmpty = false → t.maxKey! ∈ t |
ValuativeRel.Rel.rfl | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] {x : R}, x ≤ᵥ x |
Lean.Core.modifyCache | Lean.CoreM | (Lean.Core.Cache → Lean.Core.Cache) → Lean.CoreM Unit |
controlled_closure_of_complete | Mathlib.Analysis.Normed.Group.ControlledClosure | ∀ {G : Type u_1} [inst : NormedAddCommGroup G] [CompleteSpace G] {H : Type u_2} [inst_2 : NormedAddCommGroup H]
{f : NormedAddGroupHom G H} {K : AddSubgroup H} {C ε : ℝ},
0 < C → 0 < ε → f.SurjectiveOnWith K C → f.SurjectiveOnWith K.topologicalClosure (C + ε) |
instSMulDistribClassAlgEquiv | Mathlib.RingTheory.Invariant.Basic | ∀ (A : Type u_1) (K : Type u_2) (L : Type u_3) (B : Type u_4) [inst : CommRing A] [inst_1 : CommRing B]
[inst_2 : Field K] [inst_3 : Field L] [inst_4 : Algebra A K] [inst_5 : Algebra B L] [inst_6 : IsFractionRing A K]
[inst_7 : Algebra A B] [inst_8 : Algebra K L] [inst_9 : Algebra A L] [inst_10 : IsScalarTower A K L]
[inst_11 : IsScalarTower A B L] [inst_12 : IsIntegralClosure B A L] [inst_13 : Algebra.IsAlgebraic K L],
have this := IsIntegralClosure.MulSemiringAction A K L B;
SMulDistribClass Gal(L/K) B L |
UpperSet.instCommMonoid.eq_1 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α],
UpperSet.instCommMonoid =
{ toSemigroup := UpperSet.commSemigroup.toSemigroup, toOne := UpperSet.instOne, one_mul := ⋯, mul_one := ⋯,
npow := npowRecAuto, npow_zero := ⋯, npow_succ := ⋯, mul_comm := ⋯ } |
BoundedContinuousFunction.isBounded_range | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
(f : BoundedContinuousFunction α β), Bornology.IsBounded (Set.range ⇑f) |
Matrix.superFactorial_dvd_vandermonde_det | Mathlib.LinearAlgebra.Vandermonde | ∀ {n : ℕ} (v : Fin (n + 1) → ℤ), ↑n.superFactorial ∣ (Matrix.vandermonde v).det |
Filter.Germ.instRightCancelSemigroup | Mathlib.Order.Filter.Germ.Basic | {α : Type u_1} → {l : Filter α} → {M : Type u_5} → [RightCancelSemigroup M] → RightCancelSemigroup (l.Germ M) |
_private.Mathlib.NumberTheory.Fermat.0.Nat.prod_fermatNumber._proof_1_3 | Mathlib.NumberTheory.Fermat | ∀ (n : ℕ), 2 ^ (2 ^ n * 2) - 1 = 1 + 2 ^ (2 ^ n * 2) - 2 |
IsMinOn.bddBelow | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : Preorder β] {f : α → β} {s : Set α} {a : α}, IsMinOn f s a → BddBelow (f '' s) |
Lean.Parser.ParserCategory.mk | Lean.Parser.Basic | Lean.Name →
Lean.Parser.SyntaxNodeKindSet →
Lean.Parser.PrattParsingTables → Lean.Parser.LeadingIdentBehavior → Lean.Parser.ParserCategory |
_private.Mathlib.CategoryTheory.Bicategory.Free.0.CategoryTheory.FreeBicategory._aux_Mathlib_CategoryTheory_Bicategory_Free___unexpand_CategoryTheory_FreeBicategory_Hom₂_right_unitor_inv_1 | Mathlib.CategoryTheory.Bicategory.Free | Lean.PrettyPrinter.Unexpander |
Affine.Simplex.restrict_points_coe | Mathlib.LinearAlgebra.AffineSpace.Simplex.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_5} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {n : ℕ} (s : Affine.Simplex k P n) (S : AffineSubspace k P)
(hS : affineSpan k (Set.range s.points) ≤ S) (i : Fin (n + 1)), ↑((s.restrict S hS).points i) = s.points i |
IsRelPrime.mul_add_left_left_iff | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommRing R] {x y z : R}, IsRelPrime (y * z + x) y ↔ IsRelPrime x y |
Module.Relations.Solution.postcomp_var | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] {relations : Module.Relations A} {M : Type v} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] (solution : relations.Solution M) {N : Type v'} [inst_3 : AddCommGroup N] [inst_4 : Module A N]
(f : M →ₗ[A] N) (g : relations.G), (solution.postcomp f).var g = f (solution.var g) |
PiTensorProduct.lift._proof_7 | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_1} {R : Type u_2} [inst : CommSemiring R] {s : ι → Type u_3} [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] {E : Type u_4} [inst_3 : AddCommMonoid E] [inst_4 : Module R E]
(φ : MultilinearMap R s E) (x y : PiTensorProduct R fun i => s i),
(↑(PiTensorProduct.liftAux φ)).toFun (x + y) =
(↑(PiTensorProduct.liftAux φ)).toFun x + (↑(PiTensorProduct.liftAux φ)).toFun y |
Lean.LeanOptionValue.ofString | Lean.Util.LeanOptions | String → Lean.LeanOptionValue |
CategoryTheory.Comonad.Coalgebra.eilenbergMoore._proof_2 | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {G : CategoryTheory.Comonad C} {X Y : G.Coalgebra}
(f : X ⟶ Y), CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) f = f |
Set.principalSegIio._proof_8 | Mathlib.Order.Interval.Set.InitialSeg | ∀ {α : Type u_1} [inst : Preorder α] (j b : α),
b ∈
Set.range
⇑{
toFun := fun x =>
match x with
| ⟨j_1, hj⟩ => j_1,
inj' := ⋯, map_rel_iff' := ⋯ } ↔
b < j |
MeasureTheory.measureReal_mono | Mathlib.MeasureTheory.Measure.Real | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s₁ s₂ : Set α},
s₁ ⊆ s₂ → autoParam (μ s₂ ≠ ⊤) MeasureTheory.measureReal_mono._auto_1 → μ.real s₁ ≤ μ.real s₂ |
upperBounds_Ioo | Mathlib.Order.Bounds.Basic | ∀ {γ : Type u_3} [inst : SemilatticeInf γ] [DenselyOrdered γ] {a b : γ}, a < b → upperBounds (Set.Ioo a b) = Set.Ici b |
CategoryTheory.Pretriangulated.shiftFunctorCompIsoId_op_inv_app._auto_1 | Mathlib.CategoryTheory.Triangulated.Opposite.Basic | Lean.Syntax |
Std.HashMap.Raw.contains_insert_self | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k : α} {v : β}, (m.insert k v).contains k = true |
List.iSup_mem_map_of_exists_sSup_empty_le | Mathlib.Order.ConditionallyCompleteLattice.Finset | ∀ {ι : Type u_1} {α : Type u_2} [inst : ConditionallyCompleteLinearOrder α] {l : List ι} (f : ι → α),
(∃ x ∈ l, sSup ∅ ≤ f x) → ⨆ x ∈ l, f x ∈ List.map f l |
UpperHalfPlane.metricSpaceAux._proof_3 | Mathlib.Analysis.Complex.UpperHalfPlane.Metric | uniformity UpperHalfPlane = ⨅ ε, ⨅ (_ : ε > 0), Filter.principal {p | dist p.1 p.2 < ε} |
DecidableLT._to_dual_cast_4 | Mathlib.Tactic.ToDual | (α : Type u) → [inst : LT α] → (DecidableRel fun a a_1 => a_1 < a) → DecidableLT α |
AddMonoid.Coprod.clift_apply_inl | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} {P : Type u_5} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
[inst_2 : AddZeroClass P] (f : FreeAddMonoid (M ⊕ N) →+ P) (hM₁ : f (FreeAddMonoid.of (Sum.inl 0)) = 0)
(hN₁ : f (FreeAddMonoid.of (Sum.inr 0)) = 0)
(hM :
∀ (x y : M),
f (FreeAddMonoid.of (Sum.inl (x + y))) = f (FreeAddMonoid.of (Sum.inl x) + FreeAddMonoid.of (Sum.inl y)))
(hN :
∀ (x y : N),
f (FreeAddMonoid.of (Sum.inr (x + y))) = f (FreeAddMonoid.of (Sum.inr x) + FreeAddMonoid.of (Sum.inr y)))
(x : M), (AddMonoid.Coprod.clift f hM₁ hN₁ hM hN) (AddMonoid.Coprod.inl x) = f (FreeAddMonoid.of (Sum.inl x)) |
UpperSet.instCompleteLinearOrder._proof_3 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LinearOrder α] (a b c : UpperSet α), a ≤ b → a ≤ c → a ≤ Lattice.inf b c |
PMF.toMeasure_bindOnSupport_apply | Mathlib.Probability.ProbabilityMassFunction.Monad | ∀ {α : Type u_1} {β : Type u_2} {p : PMF α} (f : (a : α) → a ∈ p.support → PMF β) (s : Set β)
[inst : MeasurableSpace β],
MeasurableSet s → (p.bindOnSupport f).toMeasure s = ∑' (a : α), p a * if h : p a = 0 then 0 else (f a h).toMeasure s |
_private.Mathlib.Analysis.Calculus.LHopital.0.HasDerivAt.lhopital_zero_nhdsNE._simp_1_2 | Mathlib.Analysis.Calculus.LHopital | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {x₁ x₂ : Filter α} {y : Filter β},
Filter.Tendsto f (x₁ ⊔ x₂) y = (Filter.Tendsto f x₁ y ∧ Filter.Tendsto f x₂ y) |
Polynomial.IsUnitTrinomial.irreducible_aux2 | Mathlib.Algebra.Polynomial.UnitTrinomial | ∀ {p q : Polynomial ℤ} {k m m' n : ℕ},
k < m →
m < n →
k < m' →
m' < n →
∀ (u v w : ℤˣ),
p = Polynomial.trinomial k m n ↑u ↑v ↑w →
q = Polynomial.trinomial k m' n ↑u ↑v ↑w → p * p.mirror = q * q.mirror → q = p ∨ q = p.mirror |
Filter.sup_prod | Mathlib.Order.Filter.Prod | ∀ {α : Type u_1} {β : Type u_2} (f₁ f₂ : Filter α) (g : Filter β), (f₁ ⊔ f₂) ×ˢ g = f₁ ×ˢ g ⊔ f₂ ×ˢ g |
Ring.DirectLimit.of._proof_2 | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] (G : ι → Type u_2) [inst_1 : (i : ι) → CommRing (G i)]
(f : (i j : ι) → i ≤ j → G i → G j) (i : ι),
(Ideal.Quotient.mk
(Ideal.span
{a |
(∃ i j, ∃ (H : i ≤ j), ∃ x, FreeCommRing.of ⟨j, f i j H x⟩ - FreeCommRing.of ⟨i, x⟩ = a) ∨
(∃ i, FreeCommRing.of ⟨i, 1⟩ - 1 = a) ∨
(∃ i x y, FreeCommRing.of ⟨i, x + y⟩ - (FreeCommRing.of ⟨i, x⟩ + FreeCommRing.of ⟨i, y⟩) = a) ∨
∃ i x y, FreeCommRing.of ⟨i, x * y⟩ - FreeCommRing.of ⟨i, x⟩ * FreeCommRing.of ⟨i, y⟩ = a}))
(FreeCommRing.of ⟨i, 1⟩) =
(Ideal.Quotient.mk
(Ideal.span
{a |
(∃ i j, ∃ (H : i ≤ j), ∃ x, FreeCommRing.of ⟨j, f i j H x⟩ - FreeCommRing.of ⟨i, x⟩ = a) ∨
(∃ i, FreeCommRing.of ⟨i, 1⟩ - 1 = a) ∨
(∃ i x y, FreeCommRing.of ⟨i, x + y⟩ - (FreeCommRing.of ⟨i, x⟩ + FreeCommRing.of ⟨i, y⟩) = a) ∨
∃ i x y, FreeCommRing.of ⟨i, x * y⟩ - FreeCommRing.of ⟨i, x⟩ * FreeCommRing.of ⟨i, y⟩ = a}))
1 |
LieAlgebra.isNilpotent_range_ad_iff._simp_1 | Mathlib.Algebra.Lie.Nilpotent | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L],
LieRing.IsNilpotent ↥(LieAlgebra.ad R L).range = LieRing.IsNilpotent L |
ProbabilityTheory.Kernel.Invariant.eq_1 | Mathlib.Probability.Kernel.Invariance | ∀ {α : Type u_1} {mα : MeasurableSpace α} (κ : ProbabilityTheory.Kernel α α) (μ : MeasureTheory.Measure α),
κ.Invariant μ = (μ.bind ⇑κ = μ) |
_private.Lean.Meta.Tactic.Try.Collect.0.Lean.Meta.Try.Collector.saveFunInd.match_1 | Lean.Meta.Tactic.Try.Collect | (motive : Option Lean.Meta.FunIndInfo → Sort u_1) →
(__do_lift : Option Lean.Meta.FunIndInfo) →
((funIndInfo : Lean.Meta.FunIndInfo) → motive (some funIndInfo)) →
((x : Option Lean.Meta.FunIndInfo) → motive x) → motive __do_lift |
Lean.Elab.Term.SyntheticMVarDecl.noConfusion | Lean.Elab.Term.TermElabM | {P : Sort u} →
{t t' : Lean.Elab.Term.SyntheticMVarDecl} → t = t' → Lean.Elab.Term.SyntheticMVarDecl.noConfusionType P t t' |
CategoryTheory.MonoidalSingleObj.endMonoidalStarFunctorEquivalence | Mathlib.CategoryTheory.Bicategory.SingleObj | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
CategoryTheory.EndMonoidal (CategoryTheory.MonoidalSingleObj.star C) ≌ C |
Stream'.Seq.lt_length_iff | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {s : Stream'.Seq α} {n : ℕ} {h : s.Terminates}, n < s.length h ↔ ∃ a, a ∈ s.get? n |
Lean.IR.LocalContext.isParam | Lean.Compiler.IR.Basic | Lean.IR.LocalContext → Lean.IR.Index → Bool |
_private.Mathlib.CategoryTheory.Sites.Sieves.0.CategoryTheory.Sieve.pullback_comp._simp_1_1 | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {R S : CategoryTheory.Sieve X},
(R = S) = ∀ ⦃Y : C⦄ (f : Y ⟶ X), R.arrows f ↔ S.arrows f |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.integrable_gaussianPDFReal._simp_1_1 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {q : NNReal}, (0 ≤ ↑q) = True |
PiNat.mem_cylinder_iff_dist_le | Mathlib.Topology.MetricSpace.PiNat | ∀ {E : ℕ → Type u_1} {x y : (n : ℕ) → E n} {n : ℕ}, y ∈ PiNat.cylinder x n ↔ dist y x ≤ (1 / 2) ^ n |
TangentBundle.chartAt | Mathlib.Geometry.Manifold.VectorBundle.Tangent | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_4} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_6}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] [inst_6 : IsManifold I 1 M] (p : TangentBundle I M),
chartAt (ModelProd H E) p =
((tangentBundleCore I M).toFiberBundleCore.localTriv (achart H p.proj)).trans
((chartAt H p.proj).prod (OpenPartialHomeomorph.refl E)) |
Fin2.fz.noConfusion | Mathlib.Data.Fin.Fin2 | {P : Sort u} → {n n' : ℕ} → n + 1 = n' + 1 → Fin2.fz ≍ Fin2.fz → (n = n' → P) → P |
_private.Mathlib.RingTheory.Unramified.LocalStructure.0.Algebra.IsUnramifiedAt.exists_hasStandardEtaleSurjectionOn_of_exists_adjoin_singleton_eq_top_aux₂._simp_1_2 | Mathlib.RingTheory.Unramified.LocalStructure | ∀ {R : Type uR} {A : Type uA} {B : Type uB} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : CommSemiring B] [inst_4 : Algebra R B] (b : B), 1 ⊗ₜ[R] b = (algebraMap B (TensorProduct R A B)) b |
dotProduct_self_star_nonneg._simp_1 | Mathlib.LinearAlgebra.Matrix.DotProduct | ∀ {n : Type u_2} {R : Type u_4} [inst : Fintype n] [inst_1 : PartialOrder R] [inst_2 : NonUnitalRing R]
[inst_3 : StarRing R] [StarOrderedRing R] (v : n → R), (0 ≤ v ⬝ᵥ star v) = True |
Matroid.RankFinite.exists_finite_isBase | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} [self : M.RankFinite], ∃ B, M.IsBase B ∧ B.Finite |
CategoryTheory.Limits.Cocone.toCostructuredArrowCocone._proof_2 | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} D]
{K : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone K) (F : CategoryTheory.Functor C D) {X : D}
(f : F.obj c.pt ⟶ X) ⦃X_1 Y : J⦄ (f_1 : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((F.mapCocone c).toCostructuredArrow.comp
((CategoryTheory.CostructuredArrow.map f).comp (CategoryTheory.CostructuredArrow.pre K F X))).map
f_1)
(CategoryTheory.CostructuredArrow.homMk (c.ι.app Y) ⋯) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CostructuredArrow.homMk (c.ι.app X_1) ⋯)
(((CategoryTheory.Functor.const J).obj (CategoryTheory.CostructuredArrow.mk f)).map f_1) |
CategoryTheory.MorphismProperty.TransfiniteCompositionOfShape.recOn | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W : CategoryTheory.MorphismProperty C} →
{J : Type w} →
[inst_1 : LinearOrder J] →
[inst_2 : SuccOrder J] →
[inst_3 : OrderBot J] →
[inst_4 : WellFoundedLT J] →
{X Y : C} →
{f : X ⟶ Y} →
{motive : W.TransfiniteCompositionOfShape J f → Sort u_1} →
(t : W.TransfiniteCompositionOfShape J f) →
((toTransfiniteCompositionOfShape : CategoryTheory.TransfiniteCompositionOfShape J f) →
(map_mem :
∀ (j : J),
¬IsMax j → W (toTransfiniteCompositionOfShape.F.map (CategoryTheory.homOfLE ⋯))) →
motive
{ toTransfiniteCompositionOfShape := toTransfiniteCompositionOfShape,
map_mem := map_mem }) →
motive t |
_private.Mathlib.Order.BooleanAlgebra.Set.0.Set.ssubset_iff_sdiff_singleton._proof_1_1 | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s t : Set α}, s ⊂ t ↔ ∃ a ∈ t, s ⊆ t \ {a} |
CategoryTheory.Limits.MultispanIndex.sndSigmaMapOfIsColimit.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape}
(I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left}
(d : CategoryTheory.Limits.Cofan I.right) (hc : CategoryTheory.Limits.IsColimit c),
I.sndSigmaMapOfIsColimit d hc =
CategoryTheory.Limits.Cofan.IsColimit.desc hc fun i =>
CategoryTheory.CategoryStruct.comp (I.snd i) (d.inj (J.snd i)) |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_717 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w_1 : α),
List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] {g a, g (g a)}.card) + 1 ≤
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length →
List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] {g a, g (g a)}.card) <
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length |
_private.Mathlib.Dynamics.TopologicalEntropy.Semiconj.0.Dynamics.IsDynCoverOf.preimage._simp_1_4 | Mathlib.Dynamics.TopologicalEntropy.Semiconj | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {p : α → Prop} {q : β → Prop},
(∃ b, (∃ a, p a ∧ f a = b) ∧ q b) = ∃ a, p a ∧ q (f a) |
MeasureTheory.SimpleFunc.instNonUnitalNonAssocSemiring._proof_7 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : NonUnitalNonAssocSemiring β]
(a : MeasureTheory.SimpleFunc α β), a * 0 = 0 |
SimpleGraph.Subgraph.coe._proof_1 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (G' : G.Subgraph) (x x_1 : ↑G'.verts), G'.Adj ↑x ↑x_1 → G'.Adj ↑x_1 ↑x |
_private.Mathlib.FieldTheory.KummerExtension.0.isSplittingField_X_pow_sub_C_of_root_adjoin_eq_top.match_1_1 | Mathlib.FieldTheory.KummerExtension | ∀ {K : Type u_1} [inst : Field K] {L : Type u_2} [inst_1 : Field L] [inst_2 : Algebra K L]
(motive : (primitiveRoots (Module.finrank K L) K).Nonempty → Prop)
(hK : (primitiveRoots (Module.finrank K L) K).Nonempty),
(∀ (w : K) (hζ : w ∈ primitiveRoots (Module.finrank K L) K), motive ⋯) → motive hK |
RestrictedProduct.homeoBot._proof_1 | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {ι : Type u_1} {R : ι → Type u_2} {A : (i : ι) → Set (R i)},
Function.LeftInverse (fun f i => f i) fun f => ⟨fun i => f i, ⋯⟩ |
IsScalarTower.invertibleAlgebraCoeNat._proof_1 | Mathlib.RingTheory.AlgebraTower | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
IsScalarTower ℕ R A |
_private.Mathlib.Analysis.SpecificLimits.FloorPow.0.sum_div_pow_sq_le_div_sq._simp_1_9 | Mathlib.Analysis.SpecificLimits.FloorPow | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False |
CategoryTheory.Limits.isColimitCoconeOfHasColimitCurryCompColim._proof_2 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_5} {K : Type u_6} [inst : CategoryTheory.Category.{u_3, u_5} J]
[inst_1 : CategoryTheory.Category.{u_4, u_6} K] {C : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} C]
(G : CategoryTheory.Functor (J × K) C) [inst_3 : CategoryTheory.Limits.HasColimitsOfShape K C]
[inst_4 : CategoryTheory.Limits.HasColimit ((CategoryTheory.Functor.curry.obj G).comp CategoryTheory.Limits.colim)]
(c' : CategoryTheory.Limits.Cocone G) (f : J × K),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Limits.coconeOfHasColimitCurryCompColim G).ι.app f)
(CategoryTheory.Limits.colimit.desc ((CategoryTheory.Functor.curry.obj G).comp CategoryTheory.Limits.colim)
(CategoryTheory.Limits.coconeOfCoconeCurry G
(fun j => CategoryTheory.Limits.colimit.isColimit ((CategoryTheory.Functor.curry.obj G).obj j)) c')) =
c'.ι.app f |
IsMulFreimanHom.inv | Mathlib.Combinatorics.Additive.FreimanHom | ∀ {α : Type u_2} {β : Type u_3} [inst : CommMonoid α] [inst_1 : DivisionCommMonoid β] {A : Set α} {B : Set β}
{f : α → β} {n : ℕ}, IsMulFreimanHom n A B f → IsMulFreimanHom n A B⁻¹ f⁻¹ |
_private.Mathlib.Algebra.Polynomial.Expand.0.Polynomial.contract_mul_expand._simp_1_2 | Mathlib.Algebra.Polynomial.Expand | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ |
_private.Mathlib.SetTheory.Ordinal.Arithmetic.0.Ordinal.lt_omega0._simp_1_2 | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ {c : Cardinal.{u_1}} {o : Ordinal.{u_1}}, (o < c.ord) = (o.card < c) |
_private.Init.Data.Format.Basic.0.Std.Format.SpaceResult.recOn | Init.Data.Format.Basic | {motive : Std.Format.SpaceResult✝ → Sort u} →
(t : Std.Format.SpaceResult✝¹) →
((foundLine foundFlattenedHardLine : Bool) →
(space : ℕ) →
motive { foundLine := foundLine, foundFlattenedHardLine := foundFlattenedHardLine, space := space }) →
motive t |
CategoryTheory.Endofunctor.Coalgebra.functorOfNatTrans_map_f | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C C} (α : F ⟶ G)
{X Y : CategoryTheory.Endofunctor.Coalgebra F} (f : X ⟶ Y),
((CategoryTheory.Endofunctor.Coalgebra.functorOfNatTrans α).map f).f = f.f |
CategoryTheory.Limits.PreservesColimit.rec | Mathlib.CategoryTheory.Limits.Preserves.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
{F : CategoryTheory.Functor C D} →
{motive : CategoryTheory.Limits.PreservesColimit K F → Sort u} →
((preserves :
∀ {c : CategoryTheory.Limits.Cocone K} (hc : CategoryTheory.Limits.IsColimit c),
Nonempty (CategoryTheory.Limits.IsColimit (F.mapCocone c))) →
motive ⋯) →
(t : CategoryTheory.Limits.PreservesColimit K F) → motive t |
CommRingCat.Colimits.Prequotient._sizeOf_inst | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
{inst : CategoryTheory.SmallCategory J} →
(F : CategoryTheory.Functor J CommRingCat) → [SizeOf J] → SizeOf (CommRingCat.Colimits.Prequotient F) |
Lean.Elab.Tactic.SimpKind.casesOn | Lean.Elab.Tactic.Simp | {motive : Lean.Elab.Tactic.SimpKind → Sort u} →
(t : Lean.Elab.Tactic.SimpKind) →
motive Lean.Elab.Tactic.SimpKind.simp →
motive Lean.Elab.Tactic.SimpKind.simpAll → motive Lean.Elab.Tactic.SimpKind.dsimp → motive t |
_private.Mathlib.Topology.MetricSpace.Thickening.0.Metric.eventually_notMem_thickening_of_infEDist_pos._simp_1_2 | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) |
PresheafOfModules.surjective_of_epi | Mathlib.Algebra.Category.ModuleCat.Presheaf.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M₁ M₂ : PresheafOfModules R} (f : M₁ ⟶ M₂) [CategoryTheory.Epi f] (X : Cᵒᵖ),
Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom (f.app X)) |
AddMonoidAlgebra.mapRangeRingHom._proof_5 | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_2} {S : Type u_3} (M : Type u_1) [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (v₁ v₂ : M →₀ R),
Finsupp.mapRange ⇑f ⋯ (v₁ + v₂) = Finsupp.mapRange ⇑f ⋯ v₁ + Finsupp.mapRange ⇑f ⋯ v₂ |
iInf_lt_top._simp_1 | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {s : ι → α}, (⨅ i, s i < ⊤) = ∃ i, s i < ⊤ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.