name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.PrettyPrinter.initFn._@.Lean.PrettyPrinter.Parenthesizer.3994661577._hygCtx._hyg.2 | Lean.PrettyPrinter.Parenthesizer | IO Lean.ParserCompiler.CombinatorAttribute |
Real.one_lt_sqrt_two | Mathlib.Data.Real.Sqrt | 1 < √2 |
_private.Lean.Meta.Injective.0.Lean.Meta.andProjections.go | Lean.Meta.Injective | Lean.Expr → Lean.Expr → Array Lean.Expr → Lean.MetaM (Array Lean.Expr) |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithTerminal.widePullbackShapeEquivMap.match_3 | Mathlib.CategoryTheory.WithTerminal.Basic | {J : Type u_1} →
(motive :
(x y : CategoryTheory.Limits.WidePullbackShape J) →
(CategoryTheory.WithTerminal.widePullbackShapeEquivObj✝ x ⟶
CategoryTheory.WithTerminal.widePullbackShapeEquivObj✝¹ y) →
Sort u_2) →
(x y : CategoryTheory.Limits.WidePullbackShape J) →
(f :
CategoryTheory.WithTerminal.widePullbackShapeEquivObj✝² x ⟶
CategoryTheory.WithTerminal.widePullbackShapeEquivObj✝³ y) →
((x y : J) →
(f :
CategoryTheory.WithTerminal.widePullbackShapeEquivObj✝⁴ (some x) ⟶
CategoryTheory.WithTerminal.widePullbackShapeEquivObj✝⁵ (some y)) →
motive (some x) (some y) f) →
((y : J) →
(f :
CategoryTheory.WithTerminal.widePullbackShapeEquivObj✝⁶ none ⟶
CategoryTheory.WithTerminal.widePullbackShapeEquivObj✝⁷ (some y)) →
motive none (some y) f) →
((x : J) →
(f :
CategoryTheory.WithTerminal.widePullbackShapeEquivObj✝⁸ (some x) ⟶
CategoryTheory.WithTerminal.widePullbackShapeEquivObj✝⁹ none) →
motive (some x) none f) →
((f :
CategoryTheory.WithTerminal.widePullbackShapeEquivObj✝¹⁰ none ⟶
CategoryTheory.WithTerminal.widePullbackShapeEquivObj✝¹¹ none) →
motive none none f) →
motive x y f |
SMulPosMono | Mathlib.Algebra.Order.Module.Defs | (α : Type u_1) → (β : Type u_2) → [SMul α β] → [Preorder α] → [Preorder β] → [Zero β] → Prop |
_private.Batteries.Data.List.Lemmas.0.List.pos_findIdxNth_getElem._proof_1_10 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α) {n : ℕ}
{h : List.findIdxNth p (head :: tail) n < (head :: tail).length},
n = 0 → ¬p head = true → List.findIdxNth p tail 0 < tail.length |
_private.Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo.0.Matrix.isParabolic_iff_exists._simp_1_5 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | ∀ {n : Type u_3} {α : Type u_11} [inst : Semiring α] [inst_1 : DecidableEq n] [inst_2 : Fintype n] [Nonempty n]
{r s : α}, ((Matrix.scalar n) r = (Matrix.scalar n) s) = (r = s) |
Lean.Compiler.LCNF.Code.ctorElimType | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → {motive_4 : Lean.Compiler.LCNF.Code pu → Sort u} → ℕ → Sort (max 1 u) |
Std.instCommutativeAnd | Init.Core | Std.Commutative And |
IsDenseInducing.casesOn | Mathlib.Topology.DenseEmbedding | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
{i : α → β} →
{motive : IsDenseInducing i → Sort u} →
(t : IsDenseInducing i) →
((toIsInducing : Topology.IsInducing i) → (dense : DenseRange i) → motive ⋯) → motive t |
ModuleCat.monModuleEquivalenceAlgebra._proof_29 | Mathlib.CategoryTheory.Monoidal.Internal.Module | ∀ {R : Type u_1} [inst : CommRing R] (A : AlgCat R) (x : R), id ((algebraMap R ↑A) x) = id ((algebraMap R ↑A) x) |
Lean.Elab.Term.ContainsPendingMVar.visit | Lean.Elab.Term.TermElabM | Lean.Expr → Lean.Elab.Term.ContainsPendingMVar.M Unit |
IntermediateField.AdjoinSimple.norm_gen_eq_prod_roots | Mathlib.RingTheory.Norm.Basic | ∀ {K : Type u_4} {L : Type u_5} {F : Type u_6} [inst : Field K] [inst_1 : Field L] [inst_2 : Field F]
[inst_3 : Algebra K L] [inst_4 : Algebra K F] (x : L),
(Polynomial.map (algebraMap K F) (minpoly K x)).Splits →
(algebraMap K F) ((Algebra.norm K) (IntermediateField.AdjoinSimple.gen K x)) = ((minpoly K x).aroots F).prod |
IsTorsion.subgroup | Mathlib.GroupTheory.Torsion | ∀ {G : Type u_1} [inst : Group G], Monoid.IsTorsion G → ∀ (H : Subgroup G), Monoid.IsTorsion ↥H |
MvPolynomial.instIsCancelAddOfIsLeftCancelAdd | Mathlib.Algebra.MvPolynomial.Division | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] [IsLeftCancelAdd R], IsCancelAdd (MvPolynomial σ R) |
PolishSpace.measurableEquivNatBoolOfNotCountable._proof_1 | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {α : Type u_1}, ¬Countable α → ¬Set.univ.Countable |
LipschitzWith.integral_inv_smul_sub_mul_tendsto_integral_lineDeriv_mul | Mathlib.Analysis.Calculus.Rademacher | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
{C : NNReal} {f g : E → ℝ} {μ : MeasureTheory.Measure E} [FiniteDimensional ℝ E] [μ.IsAddHaarMeasure],
LipschitzWith C f →
MeasureTheory.Integrable g μ →
∀ (v : E),
Filter.Tendsto (fun t => ∫ (x : E), t⁻¹ • (f (x + t • v) - f x) * g x ∂μ) (nhdsWithin 0 (Set.Ioi 0))
(nhds (∫ (x : E), lineDeriv ℝ f x v * g x ∂μ)) |
MeasureTheory.hittingBtwn_mem_Icc | Mathlib.Probability.Process.HittingTime | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β}
{n m : ι}, n ≤ m → ∀ (ω : Ω), MeasureTheory.hittingBtwn u s n m ω ∈ Set.Icc n m |
Homeomorph.inv.congr_simp | Mathlib.Topology.Algebra.Group.Basic | ∀ (G : Type u_1) [inst : TopologicalSpace G] [inst_1 : InvolutiveInv G] [inst_2 : ContinuousInv G],
Homeomorph.inv G = Homeomorph.inv G |
Subgroup.pi_le_iff | Mathlib.Algebra.Group.Subgroup.Finite | ∀ {η : Type u_3} {f : η → Type u_4} [inst : (i : η) → Group (f i)] [inst_1 : DecidableEq η] [Finite η]
{H : (i : η) → Subgroup (f i)} {J : Subgroup ((i : η) → f i)},
Subgroup.pi Set.univ H ≤ J ↔ ∀ (i : η), Subgroup.map (MonoidHom.mulSingle f i) (H i) ≤ J |
_private.Mathlib.Combinatorics.Additive.ErdosGinzburgZiv.0.Int.erdos_ginzburg_ziv_prime | Mathlib.Combinatorics.Additive.ErdosGinzburgZiv | ∀ {ι : Type u_1} {p : ℕ} [Fact (Nat.Prime p)] {s : Finset ι} (a : ι → ℤ),
s.card = 2 * p - 1 → ∃ t ⊆ s, t.card = p ∧ ↑p ∣ ∑ i ∈ t, a i |
Lean.Meta.Grind.getEqc | Lean.Meta.Tactic.Grind.Types | Lean.Expr → optParam Bool false → Lean.Meta.Grind.GoalM (List Lean.Expr) |
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.UniformFun.«_aux_Mathlib_Topology_UniformSpace_UniformConvergenceTopology___macroRules__private_Mathlib_Topology_UniformSpace_UniformConvergenceTopology_0_UniformFun_term𝒰(_,_,_)_1» | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | Lean.Macro |
Subgroup.exists_index_le_card_of_leftCoset_cover | Mathlib.GroupTheory.CosetCover | ∀ {G : Type u_1} [inst : Group G] {ι : Type u_2} {H : ι → Subgroup G} {g : ι → G} {s : Finset ι},
⋃ i ∈ s, g i • ↑(H i) = Set.univ → ∃ i ∈ s, (H i).FiniteIndex ∧ (H i).index ≤ s.card |
Lean.Meta.Grind.AC.Struct._sizeOf_1 | Lean.Meta.Tactic.Grind.AC.Types | Lean.Meta.Grind.AC.Struct → ℕ |
Plausible.Testable.minimizeAux | Plausible.Testable | {α : Sort u_1} →
[inst : Plausible.SampleableExt α] →
{β : α → Prop} →
[(x : α) → Plausible.Testable (β x)] →
Plausible.Configuration →
String →
Plausible.SampleableExt.proxy α →
ℕ →
OptionT Plausible.Gen
((x : Plausible.SampleableExt.proxy α) × Plausible.TestResult (β (Plausible.SampleableExt.interp x))) |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.alter._proof_8 | Std.Data.DTreeMap.Internal.Operations | ¬0 - 1 ≤ 1 → False |
_private.Mathlib.CategoryTheory.CofilteredSystem.0.CategoryTheory.Functor.isMittagLeffler_iff_subset_range_comp._simp_1_1 | Mathlib.CategoryTheory.CofilteredSystem | ∀ {J : Type u} [inst : CategoryTheory.Category.{v_1, u} J] (F : CategoryTheory.Functor J (Type v)),
F.IsMittagLeffler = ∀ (j : J), ∃ i f, F.eventualRange j = Set.range (F.map f) |
_private.Mathlib.Analysis.Convex.StrictCombination.0.StrictConvex.centerMass_mem_interior._proof_1_11 | Mathlib.Analysis.Convex.StrictCombination | ∀ {R : Type u_3} {V : Type u_2} {ι : Type u_1} [inst : Field R] {w : ι → R} {z : ι → V} (i : ι) (t : Finset ι)
(i' j' : ι),
i' ∈ insert i t →
j' ∈ insert i t →
z i' ≠ z j' →
w i' ≠ 0 →
w j' ≠ 0 →
(∀ (i'' j'' : ι), i'' ∈ t → j'' ∈ t → z i'' ≠ z j'' → w i'' ≠ 0 → w j'' = 0) →
∀ i'' ∈ t, w i'' ≠ 0 → i = i' ∨ i = j' |
MeasureTheory.Submartingale.condExp_sub_nonneg | Mathlib.Probability.Martingale.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : Preorder ι] {m0 : MeasurableSpace Ω}
{μ : MeasureTheory.Measure Ω} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E] [inst_3 : CompleteSpace E]
{ℱ : MeasureTheory.Filtration ι m0} [inst_4 : PartialOrder E] [IsOrderedAddMonoid E] {f : ι → Ω → E},
MeasureTheory.Submartingale f ℱ μ → ∀ {i j : ι}, i ≤ j → 0 ≤ᵐ[μ] μ[f j - f i | ↑ℱ i] |
Ordset.mem | Mathlib.Data.Ordmap.Ordset | {α : Type u_1} → [inst : Preorder α] → [DecidableLE α] → α → Ordset α → Bool |
Filter.Germ.LiftPred._proof_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} (p : β → Prop) (_f _g : α → β),
_f =ᶠ[l] _g → (∀ᶠ (x : α) in l, p (_f x)) = ∀ᶠ (x : α) in l, p (_g x) |
Std.ExtTreeSet.ext_contains | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] [Std.LawfulEqCmp cmp] {t₁ t₂ : Std.ExtTreeSet α cmp},
(∀ (k : α), t₁.contains k = t₂.contains k) → t₁ = t₂ |
Ring.DirectLimit.lift_injective | 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} (P : Type u_3) [inst_2 : CommRing P] (g : (i : ι) → G i →+* P)
(Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) (f i j hij x) = (g i) x) [Nonempty ι] [IsDirectedOrder ι],
(∀ (i : ι), Function.Injective ⇑(g i)) → Function.Injective ⇑(Ring.DirectLimit.lift G f P g Hg) |
affineIndependent_of_ne_of_mem_of_mem_of_notMem | Mathlib.LinearAlgebra.AffineSpace.Independent | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {s : AffineSubspace k P} {p₁ p₂ p₃ : P},
p₁ ≠ p₂ → p₁ ∈ s → p₂ ∈ s → p₃ ∉ s → AffineIndependent k ![p₁, p₂, p₃] |
_private.Lean.Compiler.LCNF.Simp.Main.0.Lean.Compiler.LCNF.Simp.simp.match_18 | Lean.Compiler.LCNF.Simp.Main | (motive : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure → Sort u_1) →
(code : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) →
((decl : Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure) →
(k : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) → motive (Lean.Compiler.LCNF.Code.let decl k)) →
((decl : Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure) →
(k : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) →
motive (Lean.Compiler.LCNF.Code.fun decl k ⋯)) →
((decl : Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure) →
(k : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) → motive (Lean.Compiler.LCNF.Code.jp decl k)) →
((fvarId : Lean.FVarId) → motive (Lean.Compiler.LCNF.Code.return fvarId)) →
((type : Lean.Expr) → motive (Lean.Compiler.LCNF.Code.unreach type)) →
((fvarId : Lean.FVarId) →
(args : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) →
motive (Lean.Compiler.LCNF.Code.jmp fvarId args)) →
((c : Lean.Compiler.LCNF.Cases Lean.Compiler.LCNF.Purity.pure) →
motive (Lean.Compiler.LCNF.Code.cases c)) →
motive code |
_private.Mathlib.Topology.Separation.Basic.0.t0Space_iff_inseparable.match_1_1 | Mathlib.Topology.Separation.Basic | ∀ (X : Type u_1) [inst : TopologicalSpace X] (motive : T0Space X → Prop) (x : T0Space X),
(∀ (h : ∀ ⦃x y : X⦄, Inseparable x y → x = y), motive ⋯) → motive x |
FundamentalGroupoidFunctor.prodToProdTop.match_1 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Product | (A : TopCat) →
(B : TopCat) →
(motive :
(x y :
↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj A) ×
↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj B)) →
(x ⟶ y) → Sort u_3) →
(x y :
↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj A) ×
↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj B)) →
(p : x ⟶ y) →
((fst : ↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj A)) →
(snd : ↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj B)) →
(fst_1 : ↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj A)) →
(snd_1 : ↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj B)) →
(p₀ : (fst, snd).1 ⟶ (fst_1, snd_1).1) →
(p₁ : (fst, snd).2 ⟶ (fst_1, snd_1).2) → motive (fst, snd) (fst_1, snd_1) (p₀, p₁)) →
motive x y p |
CategoryTheory.MonoidalCategory.externalProductBifunctorCurried_obj_obj_map_app | Mathlib.CategoryTheory.Monoidal.ExternalProduct.Basic | ∀ (J₁ : Type u₁) (J₂ : Type u₂) (C : Type u₃) [inst : CategoryTheory.Category.{v₁, u₁} J₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} J₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
[inst_3 : CategoryTheory.MonoidalCategory C] (X : CategoryTheory.Functor J₁ C) (X_1 : CategoryTheory.Functor J₂ C)
{X_2 Y : J₁} (f : X_2 ⟶ Y) (X_3 : J₂),
((((CategoryTheory.MonoidalCategory.externalProductBifunctorCurried J₁ J₂ C).obj X).obj X_1).map f).app X_3 =
CategoryTheory.MonoidalCategoryStruct.whiskerRight (X.map f) (X_1.obj X_3) |
_private.Mathlib.RingTheory.Valuation.Extension.0.Valuation.HasExtension.val_map_lt_iff._simp_1_1 | Mathlib.RingTheory.Valuation.Extension | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) |
PredOrder.prelimitRecOn._proof_4 | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : PredOrder α] (a : α) (h : ¬Order.IsPredPrelimit a),
¬IsMin (Classical.choose ⋯) |
Lean.Lsp.ClientCapabilities._sizeOf_inst | Lean.Data.Lsp.Capabilities | SizeOf Lean.Lsp.ClientCapabilities |
_private.Mathlib.CategoryTheory.Triangulated.Pretriangulated.0.CategoryTheory.Pretriangulated.Triangle.isZero₃_of_isZero₁₂._simp_1_1 | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (X : C),
CategoryTheory.Limits.IsZero X = (CategoryTheory.CategoryStruct.id X = 0) |
CategoryTheory.Bicategory.conjugateEquiv_whiskerRight | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {l₁ : a ⟶ b} {r₁ : b ⟶ a}
(adj₁ : CategoryTheory.Bicategory.Adjunction l₁ r₁) {l₁' : a ⟶ b} {r₁' : b ⟶ a}
(adj₁' : CategoryTheory.Bicategory.Adjunction l₁' r₁') {l₂ : b ⟶ c} {r₂ : c ⟶ b}
(adj₂ : CategoryTheory.Bicategory.Adjunction l₂ r₂) (φ : l₁' ⟶ l₁),
(CategoryTheory.Bicategory.conjugateEquiv (adj₁.comp adj₂) (adj₁'.comp adj₂))
(CategoryTheory.Bicategory.whiskerRight φ l₂) =
CategoryTheory.Bicategory.whiskerLeft r₂ ((CategoryTheory.Bicategory.conjugateEquiv adj₁ adj₁') φ) |
LinearMap.BilinMap.tensorDistrib._proof_27 | Mathlib.LinearAlgebra.BilinearForm.TensorProduct | ∀ (R : Type u_1) (A : Type u_2) {M₁ : Type u_3} {N₁ : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M₁] [inst_3 : AddCommMonoid N₁] [inst_4 : Algebra R A] [inst_5 : Module A M₁]
[inst_6 : Module R N₁] [inst_7 : Module A N₁] [inst_8 : IsScalarTower R A N₁],
IsScalarTower R A (M₁ →ₗ[A] M₁ →ₗ[A] N₁) |
Finset.insert_Ico_right_eq_Ico_succ | Mathlib.Order.Interval.Finset.SuccPred | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : LocallyFiniteOrder α] [inst_2 : SuccOrder α] {a b : α} [NoMaxOrder α],
a ≤ b → insert b (Finset.Ico a b) = Finset.Ico a (Order.succ b) |
CategoryTheory.Over.grpObjMkPullbackSnd_one | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
{X R S : C} {f : R ⟶ X} {g : S ⟶ X} [inst_2 : CategoryTheory.GrpObj (CategoryTheory.Over.mk f)],
CategoryTheory.MonObj.one =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.ε (CategoryTheory.Over.pullback g))
((CategoryTheory.Over.pullback g).map CategoryTheory.MonObj.one) |
CategoryTheory.Limits.pullback.lift_fst_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
[inst_1 : CategoryTheory.Limits.HasPullback f g] (h : W ⟶ X) (k : W ⟶ Y)
(w : CategoryTheory.CategoryStruct.comp h f = CategoryTheory.CategoryStruct.comp k g) {Z_1 : C} (h_1 : X ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.lift h k w)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst f g) h_1) =
CategoryTheory.CategoryStruct.comp h h_1 |
_private.Mathlib.Order.Monotone.MonovaryOrder.0.monovary_iff_exists_monotone._simp_1_1 | Mathlib.Order.Monotone.MonovaryOrder | ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : ι → α} {g : ι → β},
Monovary f g = MonovaryOn f g Set.univ |
instMonoidOrderDual.eq_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [h : Monoid α], instMonoidOrderDual = h |
instFullCondensedTypeCondensedSetUlift | Mathlib.Condensed.Functors | Condensed.ulift.Full |
ULift.seminormedCommRing._proof_13 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedCommRing α] (a b : ULift.{u_1, u_2} α), a - b = a + -b |
Matrix.IsHermitian.splits_charpoly | Mathlib.Analysis.Matrix.Spectrum | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {n : Type u_2} [inst_1 : Fintype n] {A : Matrix n n 𝕜} [inst_2 : DecidableEq n],
A.IsHermitian → A.charpoly.Splits |
Ordinal.instPosMulStrictMono | Mathlib.SetTheory.Ordinal.Arithmetic | PosMulStrictMono Ordinal.{u_4} |
CategoryTheory.Functor.IsLocallyFull | Mathlib.CategoryTheory.Sites.LocallyFullyFaithful | {C : Type uC} →
[inst : CategoryTheory.Category.{vC, uC} C] →
{D : Type uD} →
[inst_1 : CategoryTheory.Category.{vD, uD} D] →
CategoryTheory.Functor C D → CategoryTheory.GrothendieckTopology D → Prop |
List.toString | Init.Data.ToString.Basic | {α : Type u_1} → [ToString α] → List α → String |
SSet.Subcomplex.PairingCore.mk.inj | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | ∀ {X : SSet} {A : X.Subcomplex} {ι : Type v} {dim : ι → ℕ}
{simplex : (s : ι) → X.obj (Opposite.op (SimplexCategory.mk (dim s + 1)))} {index : (s : ι) → Fin (dim s + 2)}
{nonDegenerate₁ : ∀ (s : ι), simplex s ∈ X.nonDegenerate (dim s + 1)}
{nonDegenerate₂ : ∀ (s : ι), CategoryTheory.SimplicialObject.δ X (index s) (simplex s) ∈ X.nonDegenerate (dim s)}
{notMem₁ : ∀ (s : ι), simplex s ∉ A.obj (Opposite.op (SimplexCategory.mk (dim s + 1)))}
{notMem₂ :
∀ (s : ι),
CategoryTheory.SimplicialObject.δ X (index s) (simplex s) ∉ A.obj (Opposite.op (SimplexCategory.mk (dim s)))}
{injective_type₁' :
∀ {s t : ι}, { dim := dim s + 1, simplex := simplex s } = { dim := dim t + 1, simplex := simplex t } → s = t}
{injective_type₂' :
∀ {s t : ι},
{ dim := dim s, simplex := CategoryTheory.SimplicialObject.δ X (index s) (simplex s) } =
{ dim := dim t, simplex := CategoryTheory.SimplicialObject.δ X (index t) (simplex t) } →
s = t}
{type₁_ne_type₂' :
∀ (s t : ι),
{ dim := dim s + 1, simplex := simplex s } ≠
{ dim := dim t, simplex := CategoryTheory.SimplicialObject.δ X (index t) (simplex t) }}
{surjective' :
∀ (x : A.N),
∃ s,
x.toS = { dim := dim s + 1, simplex := simplex s } ∨
x.toS = { dim := dim s, simplex := CategoryTheory.SimplicialObject.δ X (index s) (simplex s) }}
{ι_1 : Type v} {dim_1 : ι_1 → ℕ} {simplex_1 : (s : ι_1) → X.obj (Opposite.op (SimplexCategory.mk (dim_1 s + 1)))}
{index_1 : (s : ι_1) → Fin (dim_1 s + 2)}
{nonDegenerate₁_1 : ∀ (s : ι_1), simplex_1 s ∈ X.nonDegenerate (dim_1 s + 1)}
{nonDegenerate₂_1 :
∀ (s : ι_1), CategoryTheory.SimplicialObject.δ X (index_1 s) (simplex_1 s) ∈ X.nonDegenerate (dim_1 s)}
{notMem₁_1 : ∀ (s : ι_1), simplex_1 s ∉ A.obj (Opposite.op (SimplexCategory.mk (dim_1 s + 1)))}
{notMem₂_1 :
∀ (s : ι_1),
CategoryTheory.SimplicialObject.δ X (index_1 s) (simplex_1 s) ∉
A.obj (Opposite.op (SimplexCategory.mk (dim_1 s)))}
{injective_type₁'_1 :
∀ {s t : ι_1},
{ dim := dim_1 s + 1, simplex := simplex_1 s } = { dim := dim_1 t + 1, simplex := simplex_1 t } → s = t}
{injective_type₂'_1 :
∀ {s t : ι_1},
{ dim := dim_1 s, simplex := CategoryTheory.SimplicialObject.δ X (index_1 s) (simplex_1 s) } =
{ dim := dim_1 t, simplex := CategoryTheory.SimplicialObject.δ X (index_1 t) (simplex_1 t) } →
s = t}
{type₁_ne_type₂'_1 :
∀ (s t : ι_1),
{ dim := dim_1 s + 1, simplex := simplex_1 s } ≠
{ dim := dim_1 t, simplex := CategoryTheory.SimplicialObject.δ X (index_1 t) (simplex_1 t) }}
{surjective'_1 :
∀ (x : A.N),
∃ s,
x.toS = { dim := dim_1 s + 1, simplex := simplex_1 s } ∨
x.toS = { dim := dim_1 s, simplex := CategoryTheory.SimplicialObject.δ X (index_1 s) (simplex_1 s) }},
{ ι := ι, dim := dim, simplex := simplex, index := index, nonDegenerate₁ := nonDegenerate₁,
nonDegenerate₂ := nonDegenerate₂, notMem₁ := notMem₁, notMem₂ := notMem₂, injective_type₁' := injective_type₁',
injective_type₂' := injective_type₂', type₁_ne_type₂' := type₁_ne_type₂', surjective' := surjective' } =
{ ι := ι_1, dim := dim_1, simplex := simplex_1, index := index_1, nonDegenerate₁ := nonDegenerate₁_1,
nonDegenerate₂ := nonDegenerate₂_1, notMem₁ := notMem₁_1, notMem₂ := notMem₂_1,
injective_type₁' := injective_type₁'_1, injective_type₂' := injective_type₂'_1,
type₁_ne_type₂' := type₁_ne_type₂'_1, surjective' := surjective'_1 } →
ι = ι_1 ∧ dim ≍ dim_1 ∧ simplex ≍ simplex_1 ∧ index ≍ index_1 |
symmDiff_sdiff | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] (a b c : α), symmDiff a b \ c = a \ (b ⊔ c) ⊔ b \ (a ⊔ c) |
ZMod.LFunction | Mathlib.NumberTheory.LSeries.ZMod | {N : ℕ} → [NeZero N] → (ZMod N → ℂ) → ℂ → ℂ |
_private.Lean.Data.Lsp.Ipc.0.Lean.Lsp.Ipc.expandOutgoingCallHierarchy.go | Lean.Data.Lsp.Ipc | ℕ →
Lean.Lsp.CallHierarchyItem →
Array Lean.Lsp.Range → Std.TreeSet String compare → Lean.Lsp.Ipc.IpcM (Lean.Lsp.Ipc.CallHierarchy × ℕ) |
Std.DHashMap.Raw.Const.getD_empty | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {a : α} {fallback : β},
Std.DHashMap.Raw.Const.getD ∅ a fallback = fallback |
exists_and_self | Init.PropLemmas | ∀ (P : Prop) (Q : P → Prop), (∃ (p : P), Q p) ∧ P ↔ ∃ (p : P), Q p |
MvQPF.Pi.repr | Mathlib.Data.QPF.Multivariate.Constructions.Sigma | {n : ℕ} →
{A : Type u} →
(F : A → TypeVec.{u} n → Type u) →
[inst : (α : A) → MvQPF (F α)] → ⦃α : TypeVec.{u} n⦄ → MvQPF.Pi F α → ↑(MvQPF.Pi.P F) α |
Std.TreeSet.get!_erase_self | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {k : α},
(t.erase k).get! k = default |
Polynomial.Splits.eq_X_sub_C_of_single_root | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : CommRing R] {f : Polynomial R} [inst_1 : IsDomain R],
f.Splits → ∀ {x : R}, f.roots = {x} → f = Polynomial.C f.leadingCoeff * (Polynomial.X - Polynomial.C x) |
Sum.Lex.noMaxOrder | Mathlib.Data.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LT β] [NoMaxOrder α] [NoMaxOrder β], NoMaxOrder (Lex (α ⊕ β)) |
Lean.Elab.Do.Context.doBlockResultType | Lean.Elab.Do.Basic | Lean.Elab.Do.Context → Lean.Expr |
Interval.completeLattice._proof_4 | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : CompleteLattice α] [inst_1 : DecidableLE α] (s₁ : Set (Interval α)),
∀ s ∈ s₁,
(if h :
⊥ ∉ s₁ ∧
∀ ⦃s : NonemptyInterval α⦄, ↑s ∈ s₁ → ∀ ⦃t : NonemptyInterval α⦄, ↑t ∈ s₁ → s.toProd.1 ≤ t.toProd.2 then
↑{ fst := ⨆ s, ⨆ (_ : ↑s ∈ s₁), s.toProd.1, snd := ⨅ s, ⨅ (_ : ↑s ∈ s₁), s.toProd.2, fst_le_snd := ⋯ }
else ⊥) ≤
s |
Std.ExtTreeMap.compare_minKey!_modify_eq | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k : α} {f : β → β}, cmp (t.modify k f).minKey! t.minKey! = Ordering.eq |
MeasureTheory.measurable_mlconvolution | Mathlib.Analysis.LConvolution | ∀ {G : Type u_1} {mG : MeasurableSpace G} [inst : Mul G] [inst_1 : Inv G] [MeasurableMul₂ G] [MeasurableInv G]
{f g : G → ENNReal} (μ : MeasureTheory.Measure G) [MeasureTheory.SFinite μ],
Measurable f → Measurable g → Measurable (MeasureTheory.mlconvolution f g μ) |
Lean.Meta.Canonicalizer.ExprVisited.noConfusion | Lean.Meta.Canonicalizer | {P : Sort u} →
{t t' : Lean.Meta.Canonicalizer.ExprVisited} → t = t' → Lean.Meta.Canonicalizer.ExprVisited.noConfusionType P t t' |
metricSpaceOfNormedAddCommGroupOfAddTorsor._proof_4 | Mathlib.Analysis.Normed.Group.AddTorsor | ∀ (V : Type u_1) (P : Type u_2) [inst : NormedAddCommGroup V] [inst_1 : AddTorsor V P] (x y : P),
↑⟨(fun x y => ‖x -ᵥ y‖) x y, ⋯⟩ = ENNReal.ofReal ‖x -ᵥ y‖ |
AffineIsometry.continuous | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {𝕜 : Type u_1} {V : Type u_2} {V₂ : Type u_5} {P : Type u_10} {P₂ : Type u_11} [inst : NormedField 𝕜]
[inst_1 : SeminormedAddCommGroup V] [inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P]
[inst_4 : NormedAddTorsor V P] [inst_5 : SeminormedAddCommGroup V₂] [inst_6 : NormedSpace 𝕜 V₂]
[inst_7 : PseudoMetricSpace P₂] [inst_8 : NormedAddTorsor V₂ P₂] (f : P →ᵃⁱ[𝕜] P₂), Continuous ⇑f |
Lean.Server.Watchdog.ServerM | Lean.Server.Watchdog | Type → Type |
Lean.Lsp.CreateFile.Options.casesOn | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.CreateFile.Options → Sort u} →
(t : Lean.Lsp.CreateFile.Options) →
((overwrite ignoreIfExists : Bool) → motive { overwrite := overwrite, ignoreIfExists := ignoreIfExists }) → motive t |
Subsemigroup.coe_equivMapOfInjective_apply | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] (S : Subsemigroup M) (f : M →ₙ* N)
(hf : Function.Injective ⇑f) (x : ↥S), ↑((S.equivMapOfInjective f hf) x) = f ↑x |
CategoryTheory.bicategoricalIsoComp | Mathlib.Tactic.CategoryTheory.BicategoricalComp | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b : B} → {f g h i : a ⟶ b} → [CategoryTheory.BicategoricalCoherence g h] → (f ≅ g) → (h ≅ i) → (f ≅ i) |
SchwartzMap.bilinLeftCLM._proof_13 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {G : Type u_1} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G], SMulCommClass ℝ ℝ G |
Std.TreeMap.Equiv.keyAtIdx_eq | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {i : ℕ}
{h' : i < t₁.size} (h : t₁.Equiv t₂), t₁.keyAtIdx i h' = t₂.keyAtIdx i ⋯ |
_private.Mathlib.LinearAlgebra.SpecialLinearGroup.0.SpecialLinearGroup.centerEquivRootsOfUnity_invFun._simp_4 | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_1} {V : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup V] [inst_2 : Module R V] [Module.Free R V]
[Module.Finite R V] {g : SpecialLinearGroup R V},
(g ∈ Subgroup.center (SpecialLinearGroup R V)) = ∃ r, r ^ Module.finrank R V = 1 ∧ ↑↑g = r • LinearMap.id |
IndepMatroid.matroid_indep_iff._simp_1 | Mathlib.Combinatorics.Matroid.IndepAxioms | ∀ {α : Type u_1} {M : IndepMatroid α} {I : Set α}, M.matroid.Indep I = M.Indep I |
_private.Mathlib.Data.Num.Lemmas.0.PosNum.testBit.match_1.eq_2 | Mathlib.Data.Num.Lemmas | ∀ (motive : PosNum → ℕ → Sort u_1) (x : ℕ) (h_1 : Unit → motive PosNum.one 0) (h_2 : (x : ℕ) → motive PosNum.one x)
(h_3 : (a : PosNum) → motive a.bit0 0) (h_4 : (p : PosNum) → (n : ℕ) → motive p.bit0 n.succ)
(h_5 : (a : PosNum) → motive a.bit1 0) (h_6 : (p : PosNum) → (n : ℕ) → motive p.bit1 n.succ),
(x = 0 → False) →
(match PosNum.one, x with
| PosNum.one, 0 => h_1 ()
| PosNum.one, x => h_2 x
| a.bit0, 0 => h_3 a
| p.bit0, n.succ => h_4 p n
| a.bit1, 0 => h_5 a
| p.bit1, n.succ => h_6 p n) =
h_2 x |
Real.casesOn | Mathlib.Data.Real.Basic | {motive : ℝ → Sort u} → (t : ℝ) → ((cauchy : CauSeq.Completion.Cauchy abs) → motive { cauchy := cauchy }) → motive t |
CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation_ι_app_hom_assoc | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} K] [inst_3 : CategoryTheory.Limits.HasColimitsOfShape J C]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) (j : J) (k : K) {Z : C}
(h : CategoryTheory.Limits.colimit (F.comp ((CategoryTheory.evaluation K C).obj k)) ⟶ Z),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Limits.colimit.ι F j).app k)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation F k).hom h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.colimit.ι (F.comp ((CategoryTheory.evaluation K C).obj k)) j) h |
CategoryTheory.MonoidalCategory.tensorRightTensor._proof_1 | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C)
{Z Z' : C} (f : Z ⟶ Z'),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.MonoidalCategory.tensorRight (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)).map f)
((fun Z => (CategoryTheory.MonoidalCategoryStruct.associator Z X Y).symm) Z').hom =
CategoryTheory.CategoryStruct.comp ((fun Z => (CategoryTheory.MonoidalCategoryStruct.associator Z X Y).symm) Z).hom
(((CategoryTheory.MonoidalCategory.tensorRight X).comp (CategoryTheory.MonoidalCategory.tensorRight Y)).map f) |
MeasureTheory.Measure.withDensityᵥ._proof_2 | Mathlib.MeasureTheory.VectorMeasure.WithDensity | ∀ {α : Type u_2} {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {m : MeasurableSpace α}
(μ : MeasureTheory.Measure α) (f : α → E),
MeasureTheory.Integrable f μ →
∀ (s : ℕ → Set α),
(∀ (i : ℕ), MeasurableSet (s i)) →
Pairwise (Function.onFun Disjoint s) →
HasSum (fun i => if MeasurableSet (s i) then ∫ (x : α) in s i, f x ∂μ else 0)
(if MeasurableSet (⋃ i, s i) then ∫ (x : α) in ⋃ i, s i, f x ∂μ else 0) |
Finsupp.mapDomain_support_of_injective | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] [inst_1 : DecidableEq β] {f : α → β},
Function.Injective f → ∀ (s : α →₀ M), (Finsupp.mapDomain f s).support = Finset.image f s.support |
Fin.dfoldlM_zero | Batteries.Data.Fin.Fold | ∀ {m : Type u_1 → Type u_2} {α : Fin (0 + 1) → Type u_1} [inst : Monad m]
(f : (i : Fin 0) → α i.castSucc → m (α i.succ)) (x : α 0), Fin.dfoldlM 0 α f x = pure x |
HasProdLocallyUniformlyOn.mono | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] {f : ι → β → α} {g : β → α} {s : Set β}
[inst_1 : UniformSpace α] [inst_2 : TopologicalSpace β] {t : Set β},
HasProdLocallyUniformlyOn f g t → s ⊆ t → HasProdLocallyUniformlyOn f g s |
AlgEquiv.uniqueProd_apply | Mathlib.Algebra.Algebra.Prod | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : Unique B] (self : B × A), AlgEquiv.uniqueProd self = self.2 |
Finset.card_le_card_of_forall_subsingleton | Mathlib.Combinatorics.Enumerative.DoubleCounting | ∀ {α : Type u_2} {β : Type u_3} (r : α → β → Prop) {s : Finset α} {t : Finset β},
(∀ a ∈ s, ∃ b ∈ t, r a b) → (∀ b ∈ t, {a | a ∈ s ∧ r a b}.Subsingleton) → s.card ≤ t.card |
Affine.Triangle.prod_div_one_sub_eq_one_of_mem_line_point_lineMap | Mathlib.LinearAlgebra.AffineSpace.Ceva | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Field k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {t : Affine.Triangle k P} {r : Fin 3 → k},
(∀ (i : Fin 3), r i ≠ 0) →
∀ {p' : P},
(∀ (i : Fin 3), p' ∈ affineSpan k {t.points i, (AffineMap.lineMap (t.points (i + 1)) (t.points (i + 2))) (r i)}) →
∏ i, r i / (1 - r i) = 1 |
Lean.FromJson.ctorIdx | Lean.Data.Json.FromToJson.Basic | {α : Type u} → Lean.FromJson α → ℕ |
Finsupp.instAddCommGroup._proof_1 | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_1} {G : Type u_2} [inst : AddCommGroup G], Function.Injective fun f => ⇑f |
Lean.Elab.Tactic.GuardExpr.MatchKind.syntactic.elim | Lean.Elab.Tactic.Guard | {motive : Lean.Elab.Tactic.GuardExpr.MatchKind → Sort u} →
(t : Lean.Elab.Tactic.GuardExpr.MatchKind) →
t.ctorIdx = 0 → motive Lean.Elab.Tactic.GuardExpr.MatchKind.syntactic → motive t |
_private.Mathlib.Order.Partition.Finpartition.0.Finpartition.ofExistsUnique._simp_1 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} {ι : Type u_3} [inst : DistribLattice α] [inst_1 : OrderBot α] {s : Finset ι} {f : ι → α},
s.SupIndep f = (↑s).PairwiseDisjoint f |
UniformEquiv.coe_prodCongr | Mathlib.Topology.UniformSpace.Equiv | ∀ {α : Type u} {β : Type u_1} {γ : Type u_2} {δ : Type u_3} [inst : UniformSpace α] [inst_1 : UniformSpace β]
[inst_2 : UniformSpace γ] [inst_3 : UniformSpace δ] (h₁ : α ≃ᵤ β) (h₂ : γ ≃ᵤ δ), ⇑(h₁.prodCongr h₂) = Prod.map ⇑h₁ ⇑h₂ |
AddMonoidHom.toAddEquiv.congr_simp | Mathlib.Algebra.Colimit.Module | ∀ {M : Type u_4} {N : Type u_5} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f f_1 : M →+ N) (e_f : f = f_1)
(g g_1 : N →+ M) (e_g : g = g_1) (h₁ : g.comp f = AddMonoidHom.id M) (h₂ : f.comp g = AddMonoidHom.id N),
f.toAddEquiv g h₁ h₂ = f_1.toAddEquiv g_1 ⋯ ⋯ |
Lean.Meta.Grind.Arith.Linear.EqCnstr.collectDecVars._unsafe_rec | Lean.Meta.Tactic.Grind.Arith.Linear.Proof | Lean.Meta.Grind.Arith.Linear.EqCnstr → Lean.Meta.Grind.Arith.CollectDecVarsM Unit |
Finsupp.equivFunOnFinite_single | Mathlib.Data.Finsupp.Single | ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] [inst_1 : DecidableEq α] [inst_2 : Finite α] (x : α) (m : M),
(Finsupp.equivFunOnFinite fun₀ | x => m) = Pi.single x m |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.