name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.Limits.IsColimit.OfNatIso.homOfCocone.eq_1 | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {X : C} (h : F.cocones.CorepresentableBy X) (s : CategoryTheory.Limits.Cocone F),
CategoryTheory.Limits.IsColimit.OfNatIso.homOfCocone h s = h.homEquiv.symm s.ι |
Std.DTreeMap.get_erase | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] {k a : α} {h' : a ∈ t.erase k}, (t.erase k).get a h' = t.get a ⋯ |
GradeMaxOrder.mk.noConfusion | Mathlib.Order.Grade | {𝕆 : Type u_5} →
{α : Type u_6} →
{inst : Preorder 𝕆} →
{inst_1 : Preorder α} →
{P : Sort u} →
{toGradeOrder : GradeOrder 𝕆 α} →
{isMax_grade : ∀ ⦃a : α⦄, IsMax a → IsMax (GradeOrder.grade a)} →
{toGradeOrder' : GradeOrder 𝕆 α} →
{isMax_grade' : ∀ ⦃a : α⦄, IsMax a → IsMax (GradeOrder.grade a)} →
{ toGradeOrder := toGradeOrder, isMax_grade := isMax_grade } =
{ toGradeOrder := toGradeOrder', isMax_grade := isMax_grade' } →
(toGradeOrder ≍ toGradeOrder' → P) → P |
MulSemiringAction.ctorIdx | Mathlib.Algebra.Ring.Action.Basic | {M : Type u} → {R : Type v} → {inst : Monoid M} → {inst_1 : Semiring R} → MulSemiringAction M R → ℕ |
instNonemptyNormalizationMonoidOfNormalizedGCDMonoid | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [h : Nonempty (NormalizedGCDMonoid α)], Nonempty (NormalizationMonoid α) |
OrderEmbedding.birkhoffSet_sup | Mathlib.Order.Birkhoff | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : Fintype α] [inst_2 : DecidablePred SupIrred] (a b : α),
OrderEmbedding.birkhoffSet (a ⊔ b) = OrderEmbedding.birkhoffSet a ∪ OrderEmbedding.birkhoffSet b |
CategoryTheory.Functor.CorepresentableBy | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] → CategoryTheory.Functor C (Type v) → C → Type (max (max u₁ v) v₁) |
fderivWithin_congr_set_nhdsNE | Mathlib.Analysis.Calculus.FDeriv.Congr | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {x : E} {s t : Set E},
s =ᶠ[nhdsWithin x {x}ᶜ] t → fderivWithin 𝕜 f s x = fderivWithin 𝕜 f t x |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_modify._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) |
CategoryTheory.Equivalence.isAccessibleCategory | Mathlib.CategoryTheory.Presentable.Adjunction | ∀ {C : Type u} {D : Type u'} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Category.{v', u'} D]
(e : C ≌ D) [CategoryTheory.IsAccessibleCategory.{w, v, u} C], CategoryTheory.IsAccessibleCategory.{w, v', u'} D |
Set.Iic.coe_succ_of_not_isMax | Mathlib.Order.Interval.Set.SuccOrder | ∀ {J : Type u_1} [inst : PartialOrder J] [inst_1 : SuccOrder J] {j : J} {i : ↑(Set.Iic j)},
¬IsMax i → ↑(Order.succ i) = Order.succ ↑i |
_private.Mathlib.Probability.Independence.Basic.0.ProbabilityTheory.iIndepSet_iff._simp_1_1 | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {ι : Type u_2} {x : MeasurableSpace Ω} (s : ι → Set Ω) (μ : MeasureTheory.Measure Ω),
ProbabilityTheory.iIndepSet s μ = ProbabilityTheory.iIndep (fun i => MeasurableSpace.generateFrom {s i}) μ |
TopologicalSpace.Opens.map_iSup | Mathlib.Topology.Category.TopCat.Opens | ∀ {X Y : TopCat} (f : X ⟶ Y) {ι : Type u_1} (U : ι → TopologicalSpace.Opens ↑Y),
(TopologicalSpace.Opens.map f).obj (iSup U) = iSup ((TopologicalSpace.Opens.map f).obj ∘ U) |
Option.isSome.eq_2 | Init.Data.Option.Lemmas | ∀ {α : Type u_1}, none.isSome = false |
Chebyshev.psi.eq_1 | Mathlib.NumberTheory.Chebyshev | ∀ (x : ℝ), Chebyshev.psi x = ∑ n ∈ Finset.Ioc 0 ⌊x⌋₊, ArithmeticFunction.vonMangoldt n |
WithLp.prod_continuous_ofLp | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (α : Type u_2) (β : Type u_3) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β],
Continuous WithLp.ofLp |
exteriorPower.zeroEquiv_ιMulti | Mathlib.LinearAlgebra.ExteriorPower.Basic | ∀ {R : Type u} [inst : CommRing R] {M : Type u_1} [inst_1 : AddCommGroup M] [inst_2 : Module R M] (f : Fin 0 → M),
(exteriorPower.zeroEquiv R M) ((exteriorPower.ιMulti R 0) f) = 1 |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.isDefEqArgs | Lean.Meta.ExprDefEq | Lean.Expr → Array Lean.Expr → Array Lean.Expr → Lean.MetaM Bool |
LinearMap.polar_mem | Mathlib.Analysis.LocallyConvex.Polar | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedCommRing 𝕜] [inst_1 : AddCommMonoid E]
[inst_2 : AddCommMonoid F] [inst_3 : Module 𝕜 E] [inst_4 : Module 𝕜 F] (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) (s : Set E),
∀ y ∈ B.polar s, ∀ x ∈ s, ‖(B x) y‖ ≤ 1 |
RingHom.OfLocalizationSpanTarget.ofLocalizationSpan | Mathlib.RingTheory.LocalProperties.Basic | ∀ {P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop},
RingHom.OfLocalizationSpanTarget P →
RingHom.StableUnderCompositionWithLocalizationAwaySource P → RingHom.OfLocalizationSpan P |
_private.Mathlib.RingTheory.Coalgebra.Convolution.0.TensorProduct.map_convMul_map._simp_1_2 | Mathlib.RingTheory.Coalgebra.Convolution | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {R₃ : Type u_4} {M₁ : Type u_9} {M₂ : Type u_10} {M₃ : Type u_11} [inst : Semiring R₁]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂]
[inst_5 : AddCommMonoid M₃] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂} {module_M₃ : Module R₃ M₃}
{σ₁₂ : R₁ →+* R₂} {σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃} [inst_6 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] {R₄ : Type u_14}
{M₄ : Type u_15} [inst_7 : Semiring R₄] [inst_8 : AddCommMonoid M₄] [inst_9 : Module R₄ M₄] {σ₃₄ : R₃ →+* R₄}
{σ₂₄ : R₂ →+* R₄} {σ₁₄ : R₁ →+* R₄} [inst_10 : RingHomCompTriple σ₂₃ σ₃₄ σ₂₄]
[inst_11 : RingHomCompTriple σ₁₃ σ₃₄ σ₁₄] [inst_12 : RingHomCompTriple σ₁₂ σ₂₄ σ₁₄] (f : M₁ →ₛₗ[σ₁₂] M₂)
(g : M₂ →ₛₗ[σ₂₃] M₃) (h : M₃ →ₛₗ[σ₃₄] M₄), h ∘ₛₗ g ∘ₛₗ f = (h ∘ₛₗ g) ∘ₛₗ f |
Lean.Meta.Sym.IntrosResult.failed.sizeOf_spec | Lean.Meta.Sym.Intro | sizeOf Lean.Meta.Sym.IntrosResult.failed = 1 |
MulAction.QuotientAction | Mathlib.GroupTheory.GroupAction.Quotient | {α : Type u} → (β : Type v) → [inst : Group α] → [inst_1 : Monoid β] → [MulAction β α] → Subgroup α → Prop |
AffineEquiv.ofLinearEquiv | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | {k : Type u_10} →
{V : Type u_11} →
{P : Type u_12} →
[inst : Ring k] →
[inst_1 : AddCommGroup V] → [inst_2 : Module k V] → [inst_3 : AddTorsor V P] → (V ≃ₗ[k] V) → P → P → P ≃ᵃ[k] P |
IntermediateField.fixingSubgroupEquiv._proof_3 | Mathlib.FieldTheory.Galois.Basic | ∀ {F : Type u_2} [inst : Field F] {E : Type u_1} [inst_1 : Field E] [inst_2 : Algebra F E] (K : IntermediateField F E)
(x x_1 : ↥K.fixingSubgroup),
(let __src := (↑(x * x_1)).toRingEquiv;
{ toEquiv := __src.toEquiv, map_mul' := ⋯, map_add' := ⋯, commutes' := ⋯ }) =
(let __src := (↑x).toRingEquiv;
{ toEquiv := __src.toEquiv, map_mul' := ⋯, map_add' := ⋯, commutes' := ⋯ }) *
let __src := (↑x_1).toRingEquiv;
{ toEquiv := __src.toEquiv, map_mul' := ⋯, map_add' := ⋯, commutes' := ⋯ } |
ContinuousAlternatingMap.instAddCommGroup._proof_7 | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {ι : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommGroup N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N] [inst_7 : IsTopologicalAddGroup N] (x : M [⋀^ι]→L[R] N),
(-x).toContinuousMultilinearMap = (-x).toContinuousMultilinearMap |
_private.Mathlib.Algebra.Module.Submodule.Map.0.Submodule.gc_map_comap.match_1_1 | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_2} {M₂ : Type u_4} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
(motive : Submodule R M → Submodule R₂ M₂ → Prop) (x : Submodule R M) (x_1 : Submodule R₂ M₂),
(∀ (x : Submodule R M) (x_2 : Submodule R₂ M₂), motive x x_2) → motive x x_1 |
Pi.negZeroClass.eq_1 | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u} {f : I → Type v₁} [inst : (i : I) → NegZeroClass (f i)],
Pi.negZeroClass = { toZero := Pi.instZero, toNeg := Pi.instNeg, neg_zero := ⋯ } |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.resultant_dvd_leadingCoeff_pow._simp_1_1 | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u} [inst : CommSemiring R] {x : R}, IsCoprime 0 x = IsUnit x |
instAddLeftCancelSemigroupOrderDual.eq_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [h : AddLeftCancelSemigroup α], instAddLeftCancelSemigroupOrderDual = h |
AddCon.instInfSet.eq_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M],
AddCon.instInfSet = { sInf := fun S => { r := fun x y => ∀ c ∈ S, c x y, iseqv := ⋯, add' := ⋯ } } |
_private.Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory.0.CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.unitIso_inv_app_hom_app | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.MonoidalCategory D] (X : CategoryTheory.Comon (CategoryTheory.Functor C D)) (x : C),
(CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.unitIso✝.inv.app X).hom.app x =
CategoryTheory.CategoryStruct.id (X.X.obj x) |
MeasureTheory.SignedMeasure.eq_rnDeriv | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : MeasureTheory.SignedMeasure α}
(t : MeasureTheory.SignedMeasure α) (f : α → ℝ),
MeasureTheory.Integrable f μ →
MeasureTheory.VectorMeasure.MutuallySingular t μ.toENNRealVectorMeasure →
s = t + μ.withDensityᵥ f → f =ᵐ[μ] s.rnDeriv μ |
Lean.Grind.Ring.ofNat_sub | Init.Grind.Ring.Basic | ∀ {α : Type u} [inst : Lean.Grind.Ring α] {x y : ℕ}, y ≤ x → OfNat.ofNat (x - y) = OfNat.ofNat x - OfNat.ofNat y |
Set.mem_prod | Mathlib.Data.Set.Operations | ∀ {α : Type u} {β : Type v} {s : Set α} {t : Set β} {p : α × β}, p ∈ s ×ˢ t ↔ p.1 ∈ s ∧ p.2 ∈ t |
_private.Mathlib.Algebra.Order.Module.Basic.0.abs_smul._simp_1_3 | Mathlib.Algebra.Order.Module.Basic | ∀ {α : Type u_1} {β : Type u_2} {a : α} {b : β} [inst : Zero α] [inst_1 : Zero β] [inst_2 : SMulWithZero α β]
[inst_3 : Preorder α] [inst_4 : Preorder β] [SMulPosMono α β], a ≤ 0 → 0 ≤ b → (a • b ≤ 0) = True |
Lean.Elab.Tactic.evalRepeat' | Lean.Elab.Tactic.Repeat | Lean.Elab.Tactic.Tactic |
QPF.recF_eq | Mathlib.Data.QPF.Univariate.Basic | ∀ {F : Type u → Type v} [q : QPF F] {α : Type u} (g : F α → α) (x : (QPF.P F).W),
QPF.recF g x = g (QPF.abs ((QPF.P F).map (QPF.recF g) x.dest)) |
ContDiffMapSupportedInClass.map_contDiff | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {B : Type u_5} {E : outParam (Type u_6)} {F : outParam (Type u_7)} {inst : NormedAddCommGroup E}
{inst_1 : NormedAddCommGroup F} {inst_2 : NormedSpace ℝ E} {inst_3 : NormedSpace ℝ F} {n : outParam ℕ∞}
{K : outParam (TopologicalSpace.Compacts E)} [self : ContDiffMapSupportedInClass B E F n K] (f : B), ContDiff ℝ ↑n ⇑f |
_private.Mathlib.Data.Finset.Insert.0.Finset.ssubset_iff_exists_cons_subset._proof_1_1 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α}, ∀ w ∉ s, w ∉ s |
OrderIso.image_symm_image | Mathlib.Order.Hom.Set | ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] (e : α ≃o β) (s : Set β), ⇑e '' (⇑e.symm '' s) = s |
Congr!.Config.numArgsOk | Mathlib.Tactic.CongrExclamation | Congr!.Config → ℕ → Bool |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.foldl_eq_foldl_toList._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) |
AddCommGrpCat.zero_apply | Mathlib.Algebra.Category.Grp.Basic | ∀ (G H : AddCommGrpCat) (g : ↑G), (CategoryTheory.ConcreteCategory.hom 0) g = 0 |
StrictMono.injective | Mathlib.Order.Monotone.Basic | ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : Preorder β] {f : α → β},
StrictMono f → Function.Injective f |
Polynomial.C_eq_intCast | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Ring R] (n : ℤ), Polynomial.C ↑n = ↑n |
Lean.Meta.AbstractNestedProofs.Context._sizeOf_1 | Lean.Meta.AbstractNestedProofs | Lean.Meta.AbstractNestedProofs.Context → ℕ |
Function.Antiperiodic.const_inv_smul | Mathlib.Algebra.Ring.Periodic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β} {c : α} [inst : AddMonoid α] [inst_1 : Neg β]
[inst_2 : Group γ] [inst_3 : DistribMulAction γ α],
Function.Antiperiodic f c → ∀ (a : γ), Function.Antiperiodic (fun x => f (a⁻¹ • x)) (a • c) |
PNat.XgcdType.wp | Mathlib.Data.PNat.Xgcd | PNat.XgcdType → ℕ |
normalize | Mathlib.Algebra.GCDMonoid.Basic | {α : Type u_1} → [inst : CommMonoidWithZero α] → [NormalizationMonoid α] → α →*₀ α |
_private.Lean.Server.FileWorker.RequestHandling.0.Lean.Server.FileWorker.handleDocumentSymbol.toDocumentSymbols.match_1 | Lean.Server.FileWorker.RequestHandling | (motive : String × Lean.Syntax → Sort u_1) →
(x : String × Lean.Syntax) → ((name : String) → (selection : Lean.Syntax) → motive (name, selection)) → motive x |
Monovary.of_inv_right | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : CommGroup β] [inst_2 : PartialOrder β]
[IsOrderedMonoid β] {f : ι → α} {g : ι → β}, Monovary f g⁻¹ → Antivary f g |
Module.supportDim_le_ringKrullDim | Mathlib.RingTheory.KrullDimension.Module | ∀ (R : Type u_1) [inst : CommRing R] (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M],
Module.supportDim R M ≤ ringKrullDim R |
MulHom.op_symm_apply_apply | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_3} {N : Type u_4} [inst : Mul M] [inst_1 : Mul N] (f : Mᵐᵒᵖ →ₙ* Nᵐᵒᵖ) (a : M),
(MulHom.op.symm f) a = (MulOpposite.unop ∘ ⇑f ∘ MulOpposite.op) a |
CategoryTheory.WellPowered | Mathlib.CategoryTheory.Subobject.WellPowered | (C : Type u₁) → [inst : CategoryTheory.Category.{v, u₁} C] → [CategoryTheory.LocallySmall.{w, v, u₁} C] → Prop |
DyckWord.semilength_insidePart_add_semilength_outsidePart_add_one | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ {p : DyckWord}, p ≠ 0 → p.insidePart.semilength + p.outsidePart.semilength + 1 = p.semilength |
Subfield.topologicalClosure._proof_4 | Mathlib.Topology.Algebra.Field | ∀ {α : Type u_1} [inst : Field α] [inst_1 : TopologicalSpace α] [inst_2 : IsTopologicalDivisionRing α] (K : Subfield α),
1 ∈ K.topologicalClosure.carrier |
Lean.Parser.Command.namedName.parenthesizer | Lean.Parser.Syntax | Lean.PrettyPrinter.Parenthesizer |
OrderIso.IicTop._proof_2 | Mathlib.Order.Interval.Set.OrderIso | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : OrderTop α] (x : α), x ≤ ⊤ |
SimpleGraph.cliqueFree_iff | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {G : SimpleGraph α} {n : ℕ}, G.CliqueFree n ↔ IsEmpty (SimpleGraph.completeGraph (Fin n) ↪g G) |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.Cache.addGate._proof_2 | Std.Sat.AIG.CNF | ∀ {aig : Std.Sat.AIG ℕ} {cnf : Std.Sat.CNF ℕ} {lhs rhs : Std.Sat.AIG.Fanin} (cache : Std.Sat.AIG.toCNF.Cache✝ aig cnf),
∀ idx < aig.decls.size,
lhs.gate < idx ∧ rhs.gate < idx → ∀ (idx_1 : ℕ), idx = idx_1 → ¬lhs.gate < aig.decls.size → False |
op_vadd_eq_add | Mathlib.Algebra.Group.Action.Defs | ∀ {α : Type u_9} [inst : Add α] (a b : α), AddOpposite.op a +ᵥ b = b + a |
exists_pred_iterate_or | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : PredOrder α] [IsPredArchimedean α] {a b : α},
(∃ n, Order.pred^[n] a = b) ∨ ∃ n, Order.pred^[n] b = a |
_private.Mathlib.Tactic.Contrapose.0.Mathlib.Tactic.Contrapose._aux_Mathlib_Tactic_Contrapose___elabRules_Mathlib_Tactic_Contrapose_contrapose_1.match_1 | Mathlib.Tactic.Contrapose | (motive : Option Lean.Expr → Option Lean.Expr → Sort u_1) →
(x x_1 : Option Lean.Expr) →
(Unit → motive none none) →
((p : Lean.Expr) → motive (some p) none) →
((q : Lean.Expr) → motive none (some q)) → ((p q : Lean.Expr) → motive (some p) (some q)) → motive x x_1 |
Std.Tactic.BVDecide.Normalize.BitVec.ite_then_not_ite' | Std.Tactic.BVDecide.Normalize.Bool | ∀ {w : ℕ} (c0 c1 : Bool) {a b : BitVec w},
(bif c0 then ~~~bif c1 then ~~~a else b else a) = bif c0 && !c1 then ~~~b else a |
DirectSum.gMulLHom._proof_7 | Mathlib.Algebra.DirectSum.Algebra | ∀ {ι : Type u_3} (R : Type u_2) (A : ι → Type u_1) [inst : CommSemiring R] [inst_1 : (i : ι) → AddCommMonoid (A i)]
[inst_2 : (i : ι) → Module R (A i)] [inst_3 : AddMonoid ι] [inst_4 : DirectSum.GSemiring A]
[inst_5 : DirectSum.GAlgebra R A] {i j : ι} (x x_1 : A i),
{ toFun := fun b => GradedMonoid.GMul.mul (x + x_1) b, map_add' := ⋯, map_smul' := ⋯ } =
{ toFun := fun b => GradedMonoid.GMul.mul x b, map_add' := ⋯, map_smul' := ⋯ } +
{ toFun := fun b => GradedMonoid.GMul.mul x_1 b, map_add' := ⋯, map_smul' := ⋯ } |
Std.HashMap.Raw.toListRev_keysIter | Std.Data.HashMap.IteratorLemmas | ∀ {α β : Type u} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α],
m.WF → m.keysIter.toListRev = m.keys.reverse |
_private.Mathlib.Topology.Compactification.OnePoint.Basic.0.OnePoint.isOpen_iff_of_notMem._simp_1_1 | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set (OnePoint X)},
IsOpen s = ((OnePoint.infty ∈ s → IsCompact (OnePoint.some ⁻¹' s)ᶜ) ∧ IsOpen (OnePoint.some ⁻¹' s)) |
CategoryTheory.Functor.IsCartesian.domainUniqueUpToIso.congr_simp | Mathlib.CategoryTheory.FiberedCategory.Fibered | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
(p p_1 : CategoryTheory.Functor 𝒳 𝒮) (e_p : p = p_1) {R S : 𝒮} {a b : 𝒳} (f f_1 : R ⟶ S) (e_f : f = f_1)
(φ φ_1 : a ⟶ b) (e_φ : φ = φ_1) [inst_2 : p.IsCartesian f φ] {a' : 𝒳} (φ' φ'_1 : a' ⟶ b) (e_φ' : φ' = φ'_1)
[inst_3 : p.IsCartesian f φ'],
CategoryTheory.Functor.IsCartesian.domainUniqueUpToIso p f φ φ' =
CategoryTheory.Functor.IsCartesian.domainUniqueUpToIso p_1 f_1 φ_1 φ'_1 |
RootPairingCat.noConfusion | Mathlib.LinearAlgebra.RootSystem.RootPairingCat | {P : Sort u_1} →
{R : Type u} →
{inst : CommRing R} →
{t : RootPairingCat R} →
{R' : Type u} →
{inst' : CommRing R'} →
{t' : RootPairingCat R'} → R = R' → inst ≍ inst' → t ≍ t' → RootPairingCat.noConfusionType P t t' |
AlgebraicGeometry.exists_pow_mul_eq_zero_of_res_basicOpen_eq_zero_of_isCompact | Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact | ∀ (X : AlgebraicGeometry.Scheme) {U : X.Opens},
IsCompact U.carrier →
∀ (x f : ↑(X.presheaf.obj (Opposite.op U))),
TopCat.Presheaf.restrictOpen x (X.basicOpen f) ⋯ = 0 → ∃ n, f ^ n * x = 0 |
_private.Lean.AddDecl.0.Lean.isNamespaceName._sparseCasesOn_1 | Lean.AddDecl | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
Finset.subtypeInsertEquivOption._proof_11 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} [inst : DecidableEq α] {t : Finset α} {x : α} (y : ↥(insert x t)), ¬↑y = x → ↑y ∈ t |
PrimeSpectrum.comap_injective_of_surjective | Mathlib.RingTheory.Spectrum.Prime.RingHom | ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : CommSemiring S] (f : R →+* S),
Function.Surjective ⇑f → Function.Injective (PrimeSpectrum.comap f) |
_private.Mathlib.Tactic.MoveAdd.0.Lean.Expr.getExprInputs.match_1 | Mathlib.Tactic.MoveAdd | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((fn arg : Lean.Expr) → motive (fn.app arg)) →
((binderName : Lean.Name) →
(bt bb : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName bt bb binderInfo)) →
((binderName : Lean.Name) →
(bt bb : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName bt bb binderInfo)) →
((declName : Lean.Name) →
(t v b : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE declName t v b nondep)) →
((data : Lean.MData) → (e : Lean.Expr) → motive (Lean.Expr.mdata data e)) →
((typeName : Lean.Name) → (idx : ℕ) → (e : Lean.Expr) → motive (Lean.Expr.proj typeName idx e)) →
((x : Lean.Expr) → motive x) → motive x |
AlgebraicGeometry.PresheafedSpace.pushforwardDiagramToColimit._proof_2 | Mathlib.Geometry.RingedSpace.PresheafedSpace.HasColimits | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] [inst_2 : CategoryTheory.Limits.HasColimitsOfShape J TopCat]
(F : CategoryTheory.Functor J (AlgebraicGeometry.PresheafedSpace C)) (j : J),
(CategoryTheory.CategoryStruct.comp
((TopCat.Presheaf.pushforward C
(CategoryTheory.Limits.colimit.ι (F.comp (AlgebraicGeometry.PresheafedSpace.forget C)) j)).map
(F.map (CategoryTheory.CategoryStruct.id j)).c)
(CategoryTheory.CategoryStruct.comp
(TopCat.Presheaf.Pushforward.comp
((F.comp (AlgebraicGeometry.PresheafedSpace.forget C)).map (CategoryTheory.CategoryStruct.id j))
(CategoryTheory.Limits.colimit.ι (F.comp (AlgebraicGeometry.PresheafedSpace.forget C)) j)
(F.obj j).presheaf).inv
(TopCat.Presheaf.pushforwardEq ⋯ (F.obj j).presheaf).hom)).op =
CategoryTheory.CategoryStruct.id
(Opposite.op
((TopCat.Presheaf.pushforward C
(CategoryTheory.Limits.colimit.ι (F.comp (AlgebraicGeometry.PresheafedSpace.forget C)) j)).obj
(F.obj j).presheaf)) |
IsLocalizedModule.surj | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} {inst : CommSemiring R} {M : Type u_2} {M' : Type u_3} {inst_1 : AddCommMonoid M}
{inst_2 : AddCommMonoid M'} {inst_3 : Module R M} {inst_4 : Module R M'} (S : Submonoid R) (f : M →ₗ[R] M')
[self : IsLocalizedModule S f] (y : M'), ∃ x, x.2 • y = f x.1 |
Std.ExtHashMap.noConfusion | Std.Data.ExtHashMap.Basic | {P : Sort u_1} →
{α : Type u} →
{β : Type v} →
{inst : BEq α} →
{inst_1 : Hashable α} →
{t : Std.ExtHashMap α β} →
{α' : Type u} →
{β' : Type v} →
{inst' : BEq α'} →
{inst'_1 : Hashable α'} →
{t' : Std.ExtHashMap α' β'} →
α = α' → β = β' → inst ≍ inst' → inst_1 ≍ inst'_1 → t ≍ t' → Std.ExtHashMap.noConfusionType P t t' |
CategoryTheory.WithTerminal.equivComma_counitIso_hom_app_left_app | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
(X : CategoryTheory.Comma (CategoryTheory.Functor.id (CategoryTheory.Functor C D)) (CategoryTheory.Functor.const C))
(X_1 : C),
(CategoryTheory.WithTerminal.equivComma.counitIso.hom.app X).left.app X_1 =
CategoryTheory.CategoryStruct.id
(match CategoryTheory.WithTerminal.incl.obj X_1 with
| CategoryTheory.WithTerminal.of x => X.left.obj x
| CategoryTheory.WithTerminal.star => X.right) |
Batteries.AssocList.mapKey | Batteries.Data.AssocList | {α : Type u_1} → {δ : Type u_2} → {β : Type u_3} → (α → δ) → Batteries.AssocList α β → Batteries.AssocList δ β |
HMul.noConfusion | Init.Prelude | {P : Sort u_1} →
{α : Type u} →
{β : Type v} →
{γ : Type w} →
{t : HMul α β γ} →
{α' : Type u} →
{β' : Type v} →
{γ' : Type w} → {t' : HMul α' β' γ'} → α = α' → β = β' → γ = γ' → t ≍ t' → HMul.noConfusionType P t t' |
UniformSpace.isClosed_ball_of_isSymm_of_isTrans_of_mem_uniformity | Mathlib.Topology.UniformSpace.Ultra.Basic | ∀ {X : Type u_1} [inst : UniformSpace X] (x : X) {V : SetRel X X} [V.IsSymm] [V.IsTrans],
V ∈ uniformity X → IsClosed (UniformSpace.ball x V) |
String.utf8Len_le_of_suffix | Batteries.Data.String.Lemmas | ∀ {cs₁ cs₂ : List Char}, cs₁ <:+ cs₂ → String.utf8Len cs₁ ≤ String.utf8Len cs₂ |
_private.Mathlib.GroupTheory.FreeGroup.Basic.0.FreeGroup.of_injective._simp_1_3 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L₁ : List (α × Bool)} {x : α × Bool}, FreeGroup.Red [x] L₁ = (L₁ = [x]) |
Aesop.LocalNormSimpRule.rec | Aesop.Rule | {motive : Aesop.LocalNormSimpRule → Sort u} →
((id : Lean.Name) → (simpTheorem : Lean.Term) → motive { id := id, simpTheorem := simpTheorem }) →
(t : Aesop.LocalNormSimpRule) → motive t |
_private.Mathlib.Analysis.CStarAlgebra.ApproximateUnit.0.termσ | Mathlib.Analysis.CStarAlgebra.ApproximateUnit | Lean.ParserDescr |
Lean.Expr.abstractRangeM | Lean.Meta.Basic | Lean.Expr → ℕ → Array Lean.Expr → Lean.MetaM Lean.Expr |
Ultrafilter.coe_le_coe._simp_1 | Mathlib.Order.Filter.Ultrafilter.Defs | ∀ {α : Type u} {f g : Ultrafilter α}, (↑f ≤ ↑g) = (f = g) |
Lean.RArray.get_eq_getImpl | Init.Data.RArray | @Lean.RArray.get = @Lean.RArray.getImpl |
Ideal.nonPrincipals | Mathlib.RingTheory.PrincipalIdealDomain | (R : Type u) → [inst : Semiring R] → Set (Ideal R) |
Lean.Core.CoreM.parIter | Lean.Elab.Parallel | {α : Type} → List (Lean.CoreM α) → Lean.CoreM (Std.IterM Lean.CoreM (Except Lean.Exception α)) |
_private.Mathlib.Algebra.GroupWithZero.Associated.0.Associates.decompositionMonoid_iff._simp_1_1 | Mathlib.Algebra.GroupWithZero.Associated | ∀ (α : Type u_1) [inst : Semigroup α], DecompositionMonoid α = ∀ (a : α), IsPrimal a |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Inv.0.Lean.Meta.Grind.Arith.Linear.checkUppers | Lean.Meta.Tactic.Grind.Arith.Linear.Inv | Lean.Meta.Grind.Arith.Linear.LinearM Unit |
Algebra.map_bot | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] (f : A →ₐ[R] B), Subalgebra.map f ⊥ = ⊥ |
AddAction.nsmul_vadd_eq_iff_minimalPeriod_dvd | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {α : Type v} {G : Type u} [inst : AddGroup G] [inst_1 : AddAction G α] {a : G} {b : α} {n : ℕ},
n • a +ᵥ b = b ↔ Function.minimalPeriod (fun x => a +ᵥ x) b ∣ n |
CategoryTheory.Abelian.SpectralObject.cokernelSequenceE_exact._auto_3 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax |
RCLike.inv_pos | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K] {z : K}, 0 < z⁻¹ ↔ 0 < z |
List.mapIdxM.go.eq_1 | Init.Data.Array.MapIdx | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] (f : ℕ → α → m β) (x : Array β),
List.mapIdxM.go f [] x = pure x.toList |
CategoryTheory.Comonad.coalgebraPreadditive._proof_7 | Mathlib.CategoryTheory.Preadditive.EilenbergMoore | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(U : CategoryTheory.Comonad C) [inst_2 : U.Additive] (F G : U.Coalgebra) (x : F ⟶ G), { f := 0 • x.f, h := ⋯ } = 0 |
SimpleGraph.nonempty_dart_top | Mathlib.Combinatorics.SimpleGraph.Dart | ∀ {V : Type u_1} [Nontrivial V], Nonempty ⊤.Dart |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.