name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.Server.TransientWorkerILean.mk.injEq | Lean.Server.References | ∀ (moduleUri : Lean.Lsp.DocumentUri) (version : ℕ) (directImports : Lean.Server.DirectImports)
(isSetupFailure? : Option Bool) (refs : Lean.Lsp.ModuleRefs) (decls : Lean.Lsp.Decls)
(moduleUri_1 : Lean.Lsp.DocumentUri) (version_1 : ℕ) (directImports_1 : Lean.Server.DirectImports)
(isSetupFailure?_1 : Option Bool) (refs_1 : Lean.Lsp.ModuleRefs) (decls_1 : Lean.Lsp.Decls),
({ moduleUri := moduleUri, version := version, directImports := directImports, isSetupFailure? := isSetupFailure?,
refs := refs, decls := decls } =
{ moduleUri := moduleUri_1, version := version_1, directImports := directImports_1,
isSetupFailure? := isSetupFailure?_1, refs := refs_1, decls := decls_1 }) =
(moduleUri = moduleUri_1 ∧
version = version_1 ∧
directImports = directImports_1 ∧ isSetupFailure? = isSetupFailure?_1 ∧ refs = refs_1 ∧ decls = decls_1) |
RightPreLieAlgebra.instLeftPreLieAlgebraMulOpposite._proof_1 | Mathlib.Algebra.NonAssoc.PreLie.Basic | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : RightPreLieRing L] [inst_2 : RightPreLieAlgebra R L],
IsScalarTower R Lᵐᵒᵖ Lᵐᵒᵖ |
CategoryTheory.Functor.RepresentableBy.yoneda | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → (X : C) → (CategoryTheory.yoneda.obj X).RepresentableBy X |
Lean.Parser.Term.matchAltsWhereDecls.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer |
CategoryTheory.Localization.SmallShiftedHom.mk₀_comp_mk₀Inv | Mathlib.CategoryTheory.Localization.SmallShiftedHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {W : CategoryTheory.MorphismProperty C} {M : Type w'}
[inst_1 : AddMonoid M] [inst_2 : CategoryTheory.HasShift C M] {X Y : C}
[inst_3 : CategoryTheory.Localization.HasSmallLocalizedShiftedHom W M X Y]
[inst_4 : CategoryTheory.Localization.HasSmallLocalizedShiftedHom W M Y Y]
[inst_5 : CategoryTheory.Localization.HasSmallLocalizedShiftedHom W M Y X] [inst_6 : W.IsCompatibleWithShift M]
[inst_7 : W.RespectsIso] (m₀ : M) (hm₀ : m₀ = 0) (f : Y ⟶ X) (hf : W f),
(CategoryTheory.Localization.SmallShiftedHom.mk₀ W m₀ hm₀ f).comp
(CategoryTheory.Localization.SmallShiftedHom.mk₀Inv m₀ hm₀ f hf) ⋯ =
CategoryTheory.Localization.SmallShiftedHom.mk₀ W m₀ hm₀ (CategoryTheory.CategoryStruct.id Y) |
Matroid.Indep.isNonloop_of_mem | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {e : α} {I : Set α}, M.Indep I → e ∈ I → M.IsNonloop e |
MonoidAlgebra.liftNCRingHom_single | Mathlib.Algebra.MonoidAlgebra.Lift | ∀ {k : Type u₁} {G : Type u₂} {R : Type u_2} [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : Semiring R] (f : k →+* R)
(g : G →* R) (h_comm : ∀ (x : k) (y : G), Commute (f x) (g y)) (a : G) (b : k),
(MonoidAlgebra.liftNCRingHom f g h_comm) (MonoidAlgebra.single a b) = f b * g a |
AddGroupSeminorm.instSupSet._proof_2 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : AddGroup E] (s : Set (AddGroupSeminorm E)),
BddAbove s → ∀ (x y : E), ⨆ p, ↑p (x + y) ≤ (⨆ p, ↑p x) + ⨆ p, ↑p y |
CategoryTheory.Bicategory.Adjunction.homEquiv₂._proof_1 | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b c : B} {l : b ⟶ c} {r : c ⟶ b}
(adj : CategoryTheory.Bicategory.Adjunction l r) {g : a ⟶ b} {h : a ⟶ c}
(α : CategoryTheory.CategoryStruct.comp g l ⟶ h),
(fun γ =>
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight γ l)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator h r l).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft h adj.counit)
(CategoryTheory.Bicategory.rightUnitor h).hom)))
((fun α =>
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.rightUnitor g).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft g adj.unit)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator g l r).inv
(CategoryTheory.Bicategory.whiskerRight α r))))
α) =
CategoryTheory.bicategoricalComp (CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp g l))
(CategoryTheory.bicategoricalComp
(CategoryTheory.Bicategory.whiskerLeft g (CategoryTheory.Bicategory.whiskerRight adj.unit l))
(CategoryTheory.bicategoricalComp
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight α (CategoryTheory.CategoryStruct.comp r l))
(CategoryTheory.Bicategory.whiskerLeft h adj.counit))
(CategoryTheory.CategoryStruct.id h))) |
Turing.TM2.Stmt.ctorElim | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{Λ : Type u_3} →
{σ : Type u_4} →
{motive : Turing.TM2.Stmt Γ Λ σ → Sort u} →
(ctorIdx : ℕ) →
(t : Turing.TM2.Stmt Γ Λ σ) → ctorIdx = t.ctorIdx → Turing.TM2.Stmt.ctorElimType ctorIdx → motive t |
SimpleGraph.isEdgeReachable_two | Mathlib.Combinatorics.SimpleGraph.Connectivity.EdgeConnectivity | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V},
G.IsEdgeReachable 2 u v ↔ ∀ (e : Sym2 V), (G.deleteEdges {e}).Reachable u v |
LeanSearchClient.initFn._@.LeanSearchClient.LoogleSyntax.2643959438._hygCtx._hyg.2 | LeanSearchClient.LoogleSyntax | IO (IO.Ref (Std.HashMap (String × ℕ) LeanSearchClient.LoogleResult)) |
_private.Mathlib.Data.Finsupp.Basic.0.Finsupp.embDomain_trans_apply._simp_1_1 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {M : Type u_5} [inst : AddCommMonoid M] {v : α →₀ M} {f : α → β}
{g : β → γ}, Finsupp.mapDomain g (Finsupp.mapDomain f v) = Finsupp.mapDomain (g ∘ f) v |
CategoryTheory.sum.match_3 | Mathlib.CategoryTheory.Sums.Basic | (C : Type u_1) →
(D : Type u_2) →
(motive : C ⊕ D → Sort u_3) →
(X : C ⊕ D) → ((X : C) → motive (Sum.inl X)) → ((X : D) → motive (Sum.inr X)) → motive X |
_private.Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves.0.CategoryTheory.regularTopology.equalizerCondition_w._simp_1_2 | Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves | ∀ {C : Type u₁} [inst : CategoryTheory.CategoryStruct.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp g.op f.op = (CategoryTheory.CategoryStruct.comp f g).op |
List.chooseX.match_1 | Mathlib.Data.List.Defs | ∀ {α : Type u_1} (p : α → Prop) (l : α) (ls : List α) (x : α) (motive : x ∈ l :: ls ∧ p x → Prop)
(x_1 : x ∈ l :: ls ∧ p x), (∀ (o : x ∈ l :: ls) (h₂ : p x), motive ⋯) → motive x_1 |
IsGaloisGroup.fixedPoints_bot | Mathlib.FieldTheory.Galois.IsGaloisGroup | ∀ (G : Type u_1) (K : Type u_3) (L : Type u_4) [inst : Group G] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra K L] [inst_4 : MulSemiringAction G L] [inst_5 : SMulCommClass G K L],
FixedPoints.intermediateField ↥⊥ = ⊤ |
exists_enorm_lt | Mathlib.Analysis.Normed.Group.Basic | ∀ (E : Type u_8) [inst : TopologicalSpace E] [inst_1 : ESeminormedAddMonoid E] [hbot : (nhdsWithin 0 {0}ᶜ).NeBot]
{c : ENNReal}, c ≠ 0 → ∃ x, x ≠ 0 ∧ ‖x‖ₑ < c |
CategoryTheory.Limits.biprod.braid_natural | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {W X Y Z : C} (f : X ⟶ Y) (g : Z ⟶ W),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.map f g)
(CategoryTheory.Limits.biprod.braiding Y W).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.braiding X Z).hom
(CategoryTheory.Limits.biprod.map g f) |
Module.End.rTensorAlgHom._proof_1 | Mathlib.RingTheory.TensorProduct.Maps | ∀ (R : Type u_1) (M : Type u_3) (N : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N], SMulCommClass R R (TensorProduct R M N) |
Std.Tactic.BVDecide.BVPred.ExprPair._sizeOf_inst | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | SizeOf Std.Tactic.BVDecide.BVPred.ExprPair |
_private.Mathlib.Algebra.BigOperators.Field.0.Finset.dens_biUnion_le._simp_1_1 | Mathlib.Algebra.BigOperators.Field | ∀ {ι : Type u_1} {K : Type u_2} [inst : DivisionSemiring K] (s : Finset ι) (f : ι → K) (a : K),
∑ i ∈ s, f i / a = (∑ i ∈ s, f i) / a |
LieSubalgebra.coe_bracket_of_module | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (L' : LieSubalgebra R L)
{M : Type w} [inst_3 : AddCommGroup M] [inst_4 : LieRingModule L M] (x : ↥L') (m : M), ⁅x, m⁆ = ⁅↑x, m⁆ |
SimpleGraph.Subgraph.neighborSet_subset_verts | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} (G' : G.Subgraph) (v : V), G'.neighborSet v ⊆ G'.verts |
Lean.Meta.Grind.instHashableCongrKey._private_1 | Lean.Meta.Tactic.Grind.Types | {enodeMap : Lean.Meta.Grind.ENodeMap} → Lean.Meta.Grind.CongrKey enodeMap → UInt64 |
_private.Mathlib.Topology.UniformSpace.Cauchy.0.Cauchy.map_of_le._simp_1_2 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {m : α → β} {m' : β → γ},
Filter.map (m' ∘ m) f = Filter.map m' (Filter.map m f) |
_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.isEagerCasesCandidate.match_1 | Lean.Meta.Tactic.Grind.Intro | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((x : Lean.Expr) → motive x) → motive x |
_private.Mathlib.Data.Finsupp.Weight.0.Finsupp.le_degree._simp_1_2 | Mathlib.Data.Finsupp.Weight | ∀ {α : Type u} [inst : AddZeroClass α] [inst_1 : LE α] [CanonicallyOrderedAdd α] (a : α), (0 ≤ a) = True |
ENNReal.div_le_iff_le_mul | Mathlib.Data.ENNReal.Inv | ∀ {a b c : ENNReal}, b ≠ 0 ∨ c ≠ ⊤ → b ≠ ⊤ ∨ c ≠ 0 → (a / b ≤ c ↔ a ≤ c * b) |
Std.HashMap.Raw.getElem?_diff_of_not_mem_left | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ {k : α}, k ∉ m₁ → (m₁ \ m₂)[k]? = none |
CategoryTheory.Limits.pushout.desc.congr_simp | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
[inst_1 : CategoryTheory.Limits.HasPushout f g] (h h_1 : Y ⟶ W) (e_h : h = h_1) (k k_1 : Z ⟶ W) (e_k : k = k_1)
(w : CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g k),
CategoryTheory.Limits.pushout.desc h k w = CategoryTheory.Limits.pushout.desc h_1 k_1 ⋯ |
Quiver.Path.comp_inj' | Mathlib.Combinatorics.Quiver.Path | ∀ {V : Type u} [inst : Quiver V] {a b c : V} {p₁ p₂ : Quiver.Path a b} {q₁ q₂ : Quiver.Path b c},
p₁.length = p₂.length → (p₁.comp q₁ = p₂.comp q₂ ↔ p₁ = p₂ ∧ q₁ = q₂) |
Finset.prod_coe_sort | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} (s : Finset ι) [inst : CommMonoid M] (f : ι → M), ∏ i, f ↑i = ∏ i ∈ s, f i |
Lean.Grind.CutsatConfig.locals._inherited_default | Init.Grind.Config | Bool |
CStarAlgebra.norm_le_natCast_iff_of_nonneg._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | Lean.Syntax |
Matrix.reindex_mem_colStochastic | Mathlib.LinearAlgebra.Matrix.Stochastic | ∀ {R : Type u_1} {n : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R]
[inst_3 : PartialOrder R] [inst_4 : IsOrderedRing R] {m : Type u_3} [inst_5 : Fintype m] [inst_6 : DecidableEq m]
{M : Matrix n n R} {e₁ e₂ : n ≃ m}, M ∈ Matrix.colStochastic R n → (Matrix.reindex e₁ e₂) M ∈ Matrix.colStochastic R m |
QuadraticMap.zero_apply | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (x : M), 0 x = 0 |
CategoryTheory.Limits.parallelPairOpIso_inv_app_zero | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f g : X ⟶ Y),
(CategoryTheory.Limits.parallelPairOpIso f g).inv.app CategoryTheory.Limits.WalkingParallelPair.zero =
CategoryTheory.CategoryStruct.id
((CategoryTheory.Limits.walkingParallelPairOpEquiv.functor.comp (CategoryTheory.Limits.parallelPair f g).op).obj
CategoryTheory.Limits.WalkingParallelPair.zero) |
initFn._@.Mathlib.Tactic.FieldSimp.Attr.4203525765._hygCtx._hyg.2 | Mathlib.Tactic.FieldSimp.Attr | IO Lean.Meta.Simp.SimprocExtension |
Unitary.toUnits_comp_map | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_2} {S : Type u_3} [inst : Monoid R] [inst_1 : StarMul R] [inst_2 : Monoid S] [inst_3 : StarMul S]
(f : R →⋆* S), Unitary.toUnits.comp (Unitary.map f).toMonoidHom = (Units.map f.toMonoidHom).comp Unitary.toUnits |
_private.Mathlib.Topology.Separation.CompletelyRegular.0.completelyRegularSpace_iInf._simp_1_7 | Mathlib.Topology.Separation.CompletelyRegular | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) |
Std.Iterators.Types.ArrayIterator.stepAsHetT_iterFromIdxM | Std.Data.Iterators.Lemmas.Producers.Monadic.Array | ∀ {m : Type w → Type w'} [inst : Monad m] {β : Type w} [LawfulMonad m] {array : Array β} {pos : ℕ},
(array.iterFromIdxM m pos).stepAsHetT =
if x : pos < array.size then pure (Std.IterStep.yield (array.iterFromIdxM m (pos + 1)) array[pos])
else pure Std.IterStep.done |
SimpContFract.of_isContFract | Mathlib.Algebra.ContinuedFractions.Computation.Approximations | ∀ {K : Type u_1} (v : K) [inst : Field K] [inst_1 : LinearOrder K] [inst_2 : IsStrictOrderedRing K]
[inst_3 : FloorRing K], (SimpContFract.of v).IsContFract |
_private.Mathlib.MeasureTheory.Measure.ProbabilityMeasure.0.MeasureTheory.ProbabilityMeasure.coeFn_univ_ne_zero._simp_1_1 | Mathlib.MeasureTheory.Measure.ProbabilityMeasure | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (1 = 0) = False |
CategoryTheory.Limits.Types.limit_ext_iff | Mathlib.CategoryTheory.Limits.Types.Limits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] {F : CategoryTheory.Functor J (Type u)}
[inst_1 : CategoryTheory.Limits.HasLimit F] {x y : CategoryTheory.Limits.limit F},
x = y ↔ ∀ (j : J), CategoryTheory.Limits.limit.π F j x = CategoryTheory.Limits.limit.π F j y |
Tactic.ComputeAsymptotics.Seq.Stream'.dist_le_one | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | ∀ {α : Type u_1} (s t : Stream' α), dist s t ≤ 1 |
DivisionMonoid.toInvolutiveInv | Mathlib.Algebra.Group.Defs | {G : Type u} → [self : DivisionMonoid G] → InvolutiveInv G |
Std.Packages.PreorderOfLEArgs.mk.noConfusion | Init.Data.Order.PackageFactories | {α : Type u} →
{P : Sort u_1} →
{le : autoParam (LE α) Std.Packages.PreorderOfLEArgs.le._autoParam} →
{decidableLE : autoParam (DecidableLE α) Std.Packages.PreorderOfLEArgs.decidableLE._autoParam} →
{lt :
autoParam
(let this := le;
LT α)
Std.Packages.PreorderOfLEArgs.lt._autoParam} →
{beq :
autoParam
(let this := le;
let this := decidableLE;
BEq α)
Std.Packages.PreorderOfLEArgs.beq._autoParam} →
{lt_iff :
autoParam
(let this := le;
let this_1 := lt;
∀ (a b : α), a < b ↔ a ≤ b ∧ ¬b ≤ a)
Std.Packages.PreorderOfLEArgs.lt_iff._autoParam} →
{decidableLT :
autoParam
(let this := le;
let this := decidableLE;
let this := lt;
have this_1 := lt_iff;
DecidableLT α)
Std.Packages.PreorderOfLEArgs.decidableLT._autoParam} →
{beq_iff_le_and_ge :
autoParam
(let this := le;
let this_1 := decidableLE;
let this_2 := beq;
∀ (a b : α), (a == b) = true ↔ a ≤ b ∧ b ≤ a)
Std.Packages.PreorderOfLEArgs.beq_iff_le_and_ge._autoParam} →
{le_refl :
autoParam
(let this := le;
∀ (a : α), a ≤ a)
Std.Packages.PreorderOfLEArgs.le_refl._autoParam} →
{le_trans :
autoParam
(let this := le;
∀ (a b c : α), a ≤ b → b ≤ c → a ≤ c)
Std.Packages.PreorderOfLEArgs.le_trans._autoParam} →
{le' : autoParam (LE α) Std.Packages.PreorderOfLEArgs.le._autoParam} →
{decidableLE' :
autoParam (DecidableLE α) Std.Packages.PreorderOfLEArgs.decidableLE._autoParam} →
{lt' :
autoParam
(let this := le';
LT α)
Std.Packages.PreorderOfLEArgs.lt._autoParam} →
{beq' :
autoParam
(let this := le';
let this := decidableLE';
BEq α)
Std.Packages.PreorderOfLEArgs.beq._autoParam} →
{lt_iff' :
autoParam
(let this := le';
let this_1 := lt';
∀ (a b : α), a < b ↔ a ≤ b ∧ ¬b ≤ a)
Std.Packages.PreorderOfLEArgs.lt_iff._autoParam} →
{decidableLT' :
autoParam
(let this := le';
let this := decidableLE';
let this := lt';
have this_1 := lt_iff';
DecidableLT α)
Std.Packages.PreorderOfLEArgs.decidableLT._autoParam} →
{beq_iff_le_and_ge' :
autoParam
(let this := le';
let this_1 := decidableLE';
let this_2 := beq';
∀ (a b : α), (a == b) = true ↔ a ≤ b ∧ b ≤ a)
Std.Packages.PreorderOfLEArgs.beq_iff_le_and_ge._autoParam} →
{le_refl' :
autoParam
(let this := le';
∀ (a : α), a ≤ a)
Std.Packages.PreorderOfLEArgs.le_refl._autoParam} →
{le_trans' :
autoParam
(let this := le';
∀ (a b c : α), a ≤ b → b ≤ c → a ≤ c)
Std.Packages.PreorderOfLEArgs.le_trans._autoParam} →
{ le := le, decidableLE := decidableLE, lt := lt, beq := beq, lt_iff := lt_iff,
decidableLT := decidableLT, beq_iff_le_and_ge := beq_iff_le_and_ge,
le_refl := le_refl, le_trans := le_trans } =
{ le := le', decidableLE := decidableLE', lt := lt', beq := beq',
lt_iff := lt_iff', decidableLT := decidableLT',
beq_iff_le_and_ge := beq_iff_le_and_ge', le_refl := le_refl',
le_trans := le_trans' } →
(le ≍ le' →
decidableLE ≍ decidableLE' →
lt ≍ lt' → beq ≍ beq' → decidableLT ≍ decidableLT' → P) →
P |
Field.Emb.cardinal_eq_of_isSeparable | Mathlib.FieldTheory.CardinalEmb | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] [Algebra.IsSeparable F E],
Cardinal.mk (Field.Emb F E) = (fun c => if Cardinal.aleph0 ≤ c then 2 ^ c else c) (Module.rank F E) |
PowerSeries.exist_eq_span_eq_ncard_of_X_notMem | Mathlib.RingTheory.PowerSeries.Ideal | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal (PowerSeries R)} [I.IsPrime],
PowerSeries.X ∉ I →
∀ {S : Set R},
Ideal.span S = Ideal.map PowerSeries.constantCoeff I →
S.Finite → ∃ T, I = Ideal.span T ∧ T.Finite ∧ T.ncard = S.ncard |
NonUnitalSubalgebraClass.nonUnitalSeminormedRing._proof_3 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {S : Type u_2} {E : Type u_1} [inst : NonUnitalSeminormedRing E] [inst_1 : SetLike S E]
[inst_2 : NonUnitalSubringClass S E] (s : S) (a b c : ↥s), (a + b) * c = a * c + b * c |
ProbabilityTheory.integrable_rpow_mul_cexp_of_re_mem_interior_integrableExpSet | Mathlib.Probability.Moments.IntegrableExpMul | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω} {z : ℂ},
z.re ∈ interior (ProbabilityTheory.integrableExpSet X μ) →
∀ {p : ℝ}, 0 ≤ p → MeasureTheory.Integrable (fun ω => ↑(X ω ^ p) * Complex.exp (z * ↑(X ω))) μ |
SkewMonoidAlgebra.liftNCRingHom._proof_3 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : MulSemiringAction G k] {R : Type u_3}
[inst_3 : Semiring R] (f : k →+* R) (g : G →* R),
(∀ {x : k} {y : G}, f (y • x) * g y = g y * f x) →
∀ (x x_1 : SkewMonoidAlgebra k G),
(SkewMonoidAlgebra.liftNC ↑f ⇑g) (x * x_1) =
(SkewMonoidAlgebra.liftNC ↑f ⇑g) x * (SkewMonoidAlgebra.liftNC ↑f ⇑g) x_1 |
CategoryTheory.Limits.reflexivePair.mkNatIso_inv_app | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
{F G : CategoryTheory.Functor CategoryTheory.Limits.WalkingReflexivePair C}
(e₀ : F.obj CategoryTheory.Limits.WalkingReflexivePair.zero ≅ G.obj CategoryTheory.Limits.WalkingReflexivePair.zero)
(e₁ : F.obj CategoryTheory.Limits.WalkingReflexivePair.one ≅ G.obj CategoryTheory.Limits.WalkingReflexivePair.one)
(h₁ :
autoParam
(CategoryTheory.CategoryStruct.comp (F.map CategoryTheory.Limits.WalkingReflexivePair.Hom.left) e₀.hom =
CategoryTheory.CategoryStruct.comp e₁.hom (G.map CategoryTheory.Limits.WalkingReflexivePair.Hom.left))
CategoryTheory.Limits.reflexivePair.mkNatIso._auto_1)
(h₂ :
autoParam
(CategoryTheory.CategoryStruct.comp (F.map CategoryTheory.Limits.WalkingReflexivePair.Hom.right) e₀.hom =
CategoryTheory.CategoryStruct.comp e₁.hom (G.map CategoryTheory.Limits.WalkingReflexivePair.Hom.right))
CategoryTheory.Limits.reflexivePair.mkNatIso._auto_3)
(h₃ :
autoParam
(CategoryTheory.CategoryStruct.comp (F.map CategoryTheory.Limits.WalkingReflexivePair.Hom.reflexion) e₁.hom =
CategoryTheory.CategoryStruct.comp e₀.hom (G.map CategoryTheory.Limits.WalkingReflexivePair.Hom.reflexion))
CategoryTheory.Limits.reflexivePair.mkNatIso._auto_5)
(x : CategoryTheory.Limits.WalkingReflexivePair),
(CategoryTheory.Limits.reflexivePair.mkNatIso e₀ e₁ h₁ h₂ h₃).inv.app x =
match x with
| CategoryTheory.Limits.WalkingReflexivePair.zero => e₀.inv
| CategoryTheory.Limits.WalkingReflexivePair.one => e₁.inv |
Std.DTreeMap.Internal.Impl.Const.insertMany_empty_list_cons_eq_insertMany! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {k : α} {v : β} {tl : List (α × β)},
↑(Std.DTreeMap.Internal.Impl.Const.insertMany Std.DTreeMap.Internal.Impl.empty ((k, v) :: tl) ⋯) =
↑(Std.DTreeMap.Internal.Impl.Const.insertMany!
(Std.DTreeMap.Internal.Impl.insert! k v Std.DTreeMap.Internal.Impl.empty) tl) |
HahnSeries.SummableFamily.casesOn | Mathlib.RingTheory.HahnSeries.Summable | {Γ : Type u_8} →
{R : Type u_9} →
[inst : PartialOrder Γ] →
[inst_1 : AddCommMonoid R] →
{α : Type u_7} →
{motive : HahnSeries.SummableFamily Γ R α → Sort u} →
(t : HahnSeries.SummableFamily Γ R α) →
((toFun : α → HahnSeries Γ R) →
(isPWO_iUnion_support' : (⋃ a, (toFun a).support).IsPWO) →
(finite_co_support' : ∀ (g : Γ), {a | (toFun a).coeff g ≠ 0}.Finite) →
motive
{ toFun := toFun, isPWO_iUnion_support' := isPWO_iUnion_support',
finite_co_support' := finite_co_support' }) →
motive t |
_private.Mathlib.Algebra.Group.Nat.Even.0.Nat.even_pow._proof_1_2 | Mathlib.Algebra.Group.Nat.Even | ∀ {m : ℕ} (n : ℕ), (Even (m ^ n) ↔ Even m ∧ n ≠ 0) → (Even (m ^ (n + 1)) ↔ Even m ∧ ¬n + 1 = 0) |
Lean.Meta.Grind.Arith.CommRing.MonadCommSemiring.noConfusion | Lean.Meta.Tactic.Grind.Arith.CommRing.MonadSemiring | {P : Sort u} →
{m : Type → Type} →
{t : Lean.Meta.Grind.Arith.CommRing.MonadCommSemiring m} →
{m' : Type → Type} →
{t' : Lean.Meta.Grind.Arith.CommRing.MonadCommSemiring m'} →
m = m' → t ≍ t' → Lean.Meta.Grind.Arith.CommRing.MonadCommSemiring.noConfusionType P t t' |
Real.continuousAt_arctan | Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan | ∀ {x : ℝ}, ContinuousAt Real.arctan x |
Std.TreeMap.Raw.Equiv.congr_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ t₃ : Std.TreeMap.Raw α β cmp},
t₁.Equiv t₂ → (t₁.Equiv t₃ ↔ t₂.Equiv t₃) |
List.Subperm.idxInj.congr_simp | Batteries.Data.List.Perm | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : ReflBEq α] {xs ys : List α} (h : xs.Subperm ys) (i i_1 : Fin xs.length),
i = i_1 → h.idxInj i = h.idxInj i_1 |
Algebra.Generators.Hom.toAlgHom_monomial | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u} {S : Type v} {ι : Type w} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
{P : Algebra.Generators R S ι} {R' : Type u_1} {S' : Type u_2} {ι' : Type u_3} [inst_3 : CommRing R']
[inst_4 : CommRing S'] [inst_5 : Algebra R' S'] {P' : Algebra.Generators R' S' ι'} [inst_6 : Algebra R R']
[inst_7 : Algebra S S'] (f : P.Hom P') (v : ι →₀ ℕ) (r : R),
f.toAlgHom ((MvPolynomial.monomial v) r) = r • v.prod fun x1 x2 => f.val x1 ^ x2 |
Lean.Meta.Grind.EMatch.State.gmt | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.EMatch.State → ℕ |
AlgebraicGeometry.WeaklyEtale | Mathlib.AlgebraicGeometry.Morphisms.WeaklyEtale | {X Y : AlgebraicGeometry.Scheme} → (X ⟶ Y) → Prop |
_private.Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable.0.summable_jacobiTheta₂_term_iff._simp_1_2 | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | ∀ {β : Type u_2} {G : Type u_4} [inst : TopologicalSpace G] [inst_1 : AddCommGroup G] [IsTopologicalAddGroup G]
[Infinite β] [T2Space G] (a : G), (Summable fun x => a) = (a = 0) |
Std.Internal.List.containsKey_insertList_disj_of_containsKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [PartialEquivBEq α] {l toInsert : List ((a : α) × β a)} {k : α},
Std.Internal.List.containsKey k (Std.Internal.List.insertList l toInsert) =
(Std.Internal.List.containsKey k l || Std.Internal.List.containsKey k toInsert) |
left_mem_segment | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[ZeroLEOneClass 𝕜] [inst_4 : MulActionWithZero 𝕜 E] (x y : E), x ∈ segment 𝕜 x y |
CategoryTheory.yonedaMap._proof_2 | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] (F : CategoryTheory.Functor C D) (X : C) ⦃X_1 Y : Cᵒᵖ⦄ (f : X_1 ⟶ Y),
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.yoneda.obj X).map f) fun f => F.map f) =
CategoryTheory.CategoryStruct.comp (fun f => F.map f) ((F.op.comp (CategoryTheory.yoneda.obj (F.obj X))).map f) |
Order.Cofinal.above | Mathlib.Order.Ideal | {P : Type u_1} → [inst : Preorder P] → Order.Cofinal P → P → P |
Lean.Meta.Simp.Stats.recOn | Lean.Meta.Tactic.Simp.Types | {motive : Lean.Meta.Simp.Stats → Sort u} →
(t : Lean.Meta.Simp.Stats) →
((usedTheorems : Lean.Meta.Simp.UsedSimps) →
(diag : Lean.Meta.Simp.Diagnostics) → motive { usedTheorems := usedTheorems, diag := diag }) →
motive t |
padicValRat.div | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {q r : ℚ}, q ≠ 0 → r ≠ 0 → padicValRat p (q / r) = padicValRat p q - padicValRat p r |
Set.mapsTo_univ | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α), Set.MapsTo f s Set.univ |
Subspace.flip_quotDualCoannihilatorToDual_bijective | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_4} {V : Type u_5} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(W : Subspace K (Module.Dual K V)) [FiniteDimensional K ↥W],
Function.Bijective ⇑(Submodule.quotDualCoannihilatorToDual W).flip |
Lean.Elab.Term.CalcStepView.mk.noConfusion | Lean.Elab.Calc | {P : Sort u} →
{ref : Lean.Syntax} →
{term proof : Lean.Term} →
{ref' : Lean.Syntax} →
{term' proof' : Lean.Term} →
{ ref := ref, term := term, proof := proof } = { ref := ref', term := term', proof := proof' } →
(ref = ref' → term = term' → proof = proof' → P) → P |
Int.instAdd | Init.Data.Int.Basic | Add ℤ |
linarithToGrindRegressions | Mathlib.Tactic.TacticAnalysis.Declarations | Mathlib.TacticAnalysis.Config |
ZLattice.comap_refl | Mathlib.Algebra.Module.ZLattice.Basic | ∀ (K : Type u_1) [inst : NormedField K] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace K E]
(L : Submodule ℤ E), ZLattice.comap K L 1 = L |
_private.Lean.Meta.Tactic.Simp.SimpTheorems.0.Lean.Meta.isRflTheoremCore.match_1 | Lean.Meta.Tactic.Simp.SimpTheorems | (motive : Lean.ConstantInfo → Sort u_1) →
(__discr : Lean.ConstantInfo) →
((info : Lean.TheoremVal) → motive (Lean.ConstantInfo.thmInfo info)) →
((x : Lean.ConstantInfo) → motive x) → motive __discr |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_of_contains_erase._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) |
Submonoid.map._proof_2 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_3} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] (f : F) (S : Submonoid M), ∃ a ∈ ↑S, f a = 1 |
Std.DTreeMap.Raw.self_le_maxKeyD_insertIfNew | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {v : β k} {fallback : α}, (cmp k ((t.insertIfNew k v).maxKeyD fallback)).isLE = true |
Turing.TM0.Cfg.q | Mathlib.Computability.TuringMachine.PostTuringMachine | {Γ : Type u_1} → {Λ : Type u_2} → [inst : Inhabited Γ] → Turing.TM0.Cfg Γ Λ → Λ |
Lean.Name._impl.casesOn | Init.Prelude | {motive : Lean.Name._impl → Sort u} →
(t : Lean.Name._impl) →
motive Lean.Name.anonymous._impl →
((hash : UInt64) → (pre : Lean.Name) → (str : String) → motive (Lean.Name.str._impl hash pre str)) →
((hash : UInt64) → (pre : Lean.Name) → (i : ℕ) → motive (Lean.Name.num._impl hash pre i)) → motive t |
CategoryTheory.Limits.PullbackCone.mk._auto_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | Lean.Syntax |
Polynomial.resultant_zero_right_deg | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (m : ℕ), f.resultant g m 0 = g.coeff 0 ^ m |
SemimoduleCat.MonoidalCategory.leftUnitor_naturality | Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic | ∀ {R : Type u} [inst : CommSemiring R] {M N : SemimoduleCat R} (f : M ⟶ N),
CategoryTheory.CategoryStruct.comp
(SemimoduleCat.MonoidalCategory.tensorHom (CategoryTheory.CategoryStruct.id (SemimoduleCat.of R R)) f)
(SemimoduleCat.MonoidalCategory.leftUnitor N).hom =
CategoryTheory.CategoryStruct.comp (SemimoduleCat.MonoidalCategory.leftUnitor M).hom f |
AddMonoidHom.exists_mrange_eq_mgraph | Mathlib.Algebra.Group.Graph | ∀ {G : Type u_1} {H : Type u_2} {I : Type u_3} [inst : AddMonoid G] [inst_1 : AddMonoid H] [inst_2 : AddMonoid I]
{f : G →+ H × I},
Function.Surjective (Prod.fst ∘ ⇑f) →
(∀ (g₁ g₂ : G), (f g₁).1 = (f g₂).1 → (f g₁).2 = (f g₂).2) → ∃ f', AddMonoidHom.mrange f = f'.mgraph |
_private.Mathlib.SetTheory.ZFC.PSet.0.PSet.Mem.congr_left.match_1_1 | Mathlib.SetTheory.ZFC.PSet | ∀ (x : PSet.{u_1}) (α : Type u_1) (A : α → PSet.{u_1}) (motive : x ∈ PSet.mk α A → Prop) (x_1 : x ∈ PSet.mk α A),
(∀ (a : (PSet.mk α A).Type) (ha : x.Equiv ((PSet.mk α A).Func a)), motive ⋯) → motive x_1 |
CategoryTheory.ShortComplex.leftHomologyOpIso | Mathlib.Algebra.Homology.ShortComplex.RightHomology | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(S : CategoryTheory.ShortComplex C) →
[inst_2 : S.HasRightHomology] → S.op.leftHomology ≅ Opposite.op S.rightHomology |
instIsPartialOrderLe | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : PartialOrder α], IsPartialOrder α fun x1 x2 => x1 ≤ x2 |
_private.Lean.Data.Json.Basic.0.Lean.Json.beq'._sparseCasesOn_7 | Lean.Data.Json.Basic | {motive_1 : Lean.Json → Sort u} →
(t : Lean.Json) →
((elems : Array Lean.Json) → motive_1 (Lean.Json.arr elems)) →
(Nat.hasNotBit 16 t.ctorIdx → motive_1 t) → motive_1 t |
_private.Mathlib.RingTheory.DiscreteValuationRing.Basic.0.IsDiscreteValuationRing.HasUnitMulPowIrreducibleFactorization.of_ufd_of_unique_irreducible._simp_1_3 | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, ((∃ x, p x) → b) = ∀ (x : α), p x → b |
CategoryTheory.hasExt_iff_small_ext | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C],
CategoryTheory.HasExt C ↔ ∀ (X Y : C) (n : ℕ), Small.{w', w} (CategoryTheory.Abelian.Ext X Y n) |
instIsInertiaFieldOfIsGaloisGroupSubtypeAlgEquivMemSubgroupInertia | Mathlib.NumberTheory.RamificationInertia.HilbertTheory | ∀ (K : Type u_2) (L : Type u_3) {B : Type u_4} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : CommRing B] (P : Ideal B) (D : Type u_5) [inst_4 : Field D] [inst_5 : Algebra D L]
[inst_6 : MulSemiringAction Gal(L/K) B] [h : IsGaloisGroup (↥(Ideal.inertia Gal(L/K) P)) D L], IsInertiaField K L P D |
AlgebraicGeometry.Scheme.Hom.normalizationObjIso_hom_val | Mathlib.AlgebraicGeometry.Normalization | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [inst : AlgebraicGeometry.QuasiCompact f]
[inst_1 : AlgebraicGeometry.QuasiSeparated f] {U : Y.Opens} (hU : AlgebraicGeometry.IsAffineOpen U),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Hom.normalizationObjIso f hU).hom
(CommRingCat.ofHom
(integralClosure ↑(Y.presheaf.obj (Opposite.op U))
↑(X.presheaf.obj (Opposite.op ((TopologicalSpace.Opens.map f.base).obj U)))).val.toRingHom) =
AlgebraicGeometry.Scheme.Hom.appLE (AlgebraicGeometry.Scheme.Hom.toNormalization f)
((TopologicalSpace.Opens.map (AlgebraicGeometry.Scheme.Hom.fromNormalization f).base).obj U)
((TopologicalSpace.Opens.map f.base).obj U) ⋯ |
_private.Lean.Environment.0.Lean.Environment.realizeValue.unsafe_15 | Lean.Environment | {α : Type u_1} → [inst : BEq α] → [inst_1 : Hashable α] → Lean.PersistentHashMap α (Task Dynamic) → NonScalar |
WithTop.bot_eq_coe._simp_1 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : Bot α] {a : α}, (⊥ = ↑a) = (⊥ = a) |
SemicontinuousAt.eq_1 | Mathlib.Topology.Semicontinuity.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] (r : α → β → Prop) (x : α),
SemicontinuousAt r x = ∀ (y : β), r x y → ∀ᶠ (x' : α) in nhds x, r x' y |
CategoryTheory.Functor.precomposeWhiskerLeftMapCocone_inv_hom | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{D : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} D] {F : CategoryTheory.Functor J C}
{H H' : CategoryTheory.Functor C D} (α : H ≅ H') (c : CategoryTheory.Limits.Cocone F),
(CategoryTheory.Functor.precomposeWhiskerLeftMapCocone α c).inv.hom = α.inv.app c.pt |
Localization.mapToFractionRing._proof_1 | Mathlib.RingTheory.Localization.AsSubring | ∀ {A : Type u_3} (K : Type u_1) [inst : CommRing A] (S : Submonoid A) [inst_1 : CommRing K] [inst_2 : Algebra A K]
[inst_3 : IsFractionRing A K] (B : Type u_2) [inst_4 : CommRing B] [inst_5 : Algebra A B]
[inst_6 : IsLocalization S B] (hS : S ≤ nonZeroDivisors A) (a : A),
(↑↑(IsLocalization.lift ⋯)).toFun ((algebraMap A B) a) = (algebraMap A K) a |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.