name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.SingleObj.inv_as_inv | Mathlib.CategoryTheory.SingleObj | ∀ (G : Type u) [inst : Group G] {x y : CategoryTheory.SingleObj G} (f : x ⟶ y), CategoryTheory.inv f = f⁻¹ |
iSupIndep.subtype_ne_bot_le_finrank | Mathlib.LinearAlgebra.Dimension.Finite | ∀ {ι : Type w} {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [IsDomain R]
[Module.IsTorsionFree R M] [Module.Finite R M] [StrongRankCondition R] {p : ι → Submodule R M},
iSupIndep p → ∀ [inst_7 : Fintype { i // p i ≠ ⊥ }], Fintype.card { i // p i ≠ ⊥ } ≤ Module.finrank R M |
LieDerivation.SMulBracketCommClass.rec | Mathlib.Algebra.Lie.Derivation.Basic | {S : Type u_4} →
{L : Type u_5} →
{α : Type u_6} →
[inst : SMul S α] →
[inst_1 : LieRing L] →
[inst_2 : AddCommGroup α] →
[inst_3 : LieRingModule L α] →
{motive : LieDerivation.SMulBracketCommClass S L α → Sort u} →
((smul_bracket_comm : ∀ (s : S) (l : L) (a : α), s • ⁅l, a⁆ = ⁅l, s • a⁆) → motive ⋯) →
(t : LieDerivation.SMulBracketCommClass S L α) → motive t |
Lean.Grind.IntModule.OfNatModule.instLTQOfOrderedAdd | Init.Grind.Module.Envelope | {α : Type u} →
[inst : Lean.Grind.NatModule α] →
[inst_1 : LE α] →
[inst_2 : Std.IsPreorder α] → [Lean.Grind.OrderedAdd α] → LT (Lean.Grind.IntModule.OfNatModule.Q α) |
_private.Mathlib.FieldTheory.Extension.0.IntermediateField.Lifts.nonempty_algHom_of_exist_lifts_finset._simp_1_5 | Mathlib.FieldTheory.Extension | ∀ {α : Type u} [inst : SemilatticeSup α] {a b : α}, (a < a ⊔ b) = ¬b ≤ a |
HahnSeries.instDistribMulAction._proof_4 | Mathlib.RingTheory.HahnSeries.Addition | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] {V : Type u_2} [inst_1 : Monoid R] [inst_2 : AddMonoid V]
[inst_3 : DistribMulAction R V] (x : R) (x_1 x_2 : HahnSeries Γ V), x • (x_1 + x_2) = x • x_1 + x • x_2 |
PerfectClosure.instCommRing._proof_8 | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u_1) [inst : CommRing K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p]
(e f g : PerfectClosure K p), e * (f + g) = e * f + e * g |
CategoryTheory.ShortComplex.RightHomologyData.ofHasKernel_p | 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 : CategoryTheory.Limits.HasKernel S.g] (hf : S.f = 0),
(CategoryTheory.ShortComplex.RightHomologyData.ofHasKernel S hf).p = CategoryTheory.CategoryStruct.id S.X₂ |
_private.Mathlib.RingTheory.Smooth.Kaehler.0.derivationOfSectionOfKerSqZero._simp_6 | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M} (p : Submodule R M)
{x : M} (h : x ∈ p), (⟨x, h⟩ = 0) = (x = 0) |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.ExprWithHoles.mk.inj | Lean.Elab.MutualDef | ∀ {ref : Lean.Syntax} {expr : Lean.Expr} {ref_1 : Lean.Syntax} {expr_1 : Lean.Expr},
{ ref := ref, expr := expr } = { ref := ref_1, expr := expr_1 } → ref = ref_1 ∧ expr = expr_1 |
CategoryTheory.ObjectProperty.IsClosedUnderQuotients.mk | Mathlib.CategoryTheory.ObjectProperty.EpiMono | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C},
(∀ {X Y : C} (f : X ⟶ Y) [CategoryTheory.Epi f], P X → P Y) → P.IsClosedUnderQuotients |
SimpleGraph.Subgraph.symm | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} (self : G.Subgraph), Symmetric self.Adj |
Complex.instNormedField._proof_1 | Mathlib.Analysis.Complex.Basic | ∀ (x x_1 : ℂ), dist x x_1 = dist x x_1 |
Dyadic.instHShiftRightInt | Init.Data.Dyadic.Basic | HShiftRight Dyadic ℤ Dyadic |
Mathlib.Tactic.Choose.choose1WithInfo | Mathlib.Tactic.Choose | Lean.MVarId →
Bool →
Option Lean.Expr →
Mathlib.Tactic.Choose.ChooseArg → Lean.Elab.TermElabM (Mathlib.Tactic.Choose.ElimStatus × Lean.MVarId) |
_private.Mathlib.Algebra.Order.Archimedean.Basic.0.exists_int_lt.match_1_1 | Mathlib.Algebra.Order.Archimedean.Basic | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : PartialOrder R] (x : R) (motive : (∃ n, -x < ↑n) → Prop)
(x_1 : ∃ n, -x < ↑n), (∀ (n : ℤ) (h : -x < ↑n), motive ⋯) → motive x_1 |
Std.DHashMap.containsThenInsertIfNew | Std.Data.DHashMap.Basic | {α : Type u} →
{β : α → Type v} → {x : BEq α} → {x_1 : Hashable α} → Std.DHashMap α β → (a : α) → β a → Bool × Std.DHashMap α β |
Complex.sin_add_int_mul_two_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℂ) (n : ℤ), Complex.sin (x + ↑n * (2 * ↑Real.pi)) = Complex.sin x |
Option.forM_some | Init.Data.Option.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} [inst : Monad m] (f : α → m PUnit.{u_1 + 1}) (a : α), forM (some a) f = f a |
PartialEquiv.symm_image_target_eq_source | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β), ↑e.symm '' e.target = e.source |
Lean.Elab.Tactic.Do.BVarUses.rec | Lean.Elab.Tactic.Do.LetElim | {n : ℕ} →
{motive : Lean.Elab.Tactic.Do.BVarUses n → Sort u} →
motive Lean.Elab.Tactic.Do.BVarUses.none →
((uses : Vector Lean.Elab.Tactic.Do.Uses n) → motive (Lean.Elab.Tactic.Do.BVarUses.some uses)) →
(t : Lean.Elab.Tactic.Do.BVarUses n) → motive t |
Std.TreeMap.mem_union_iff | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α},
k ∈ t₁ ∪ t₂ ↔ k ∈ t₁ ∨ k ∈ t₂ |
_private.Mathlib.Topology.AlexandrovDiscrete.0.alexandrovDiscrete_iff_nhds._simp_1_2 | Mathlib.Topology.AlexandrovDiscrete | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsClosed s = ∀ (a : X), ClusterPt a (Filter.principal s) → a ∈ s |
Std.Do.PredTrans.throw | Std.Do.PredTrans | {ps : Std.Do.PostShape} → {α ε : Type u} → ε → Std.Do.PredTrans (Std.Do.PostShape.except ε ps) α |
CategoryTheory.Functor.mapSquare_obj | Mathlib.CategoryTheory.Square | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(F : CategoryTheory.Functor C D) (sq : CategoryTheory.Square C), F.mapSquare.obj sq = sq.map F |
IsTransitiveRel.eq_1 | Mathlib.Topology.UniformSpace.Ultra.Basic | ∀ {X : Type u_1} (V : SetRel X X), IsTransitiveRel V = ∀ ⦃x y z : X⦄, (x, y) ∈ V → (y, z) ∈ V → (x, z) ∈ V |
RCLike.add_conj | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K] (z : K), z + (starRingEnd K) z = 2 * ↑(RCLike.re z) |
Lean.Meta.Simp.Arith.Nat.toLinearExpr | Lean.Meta.Tactic.Simp.Arith.Nat.Basic | Lean.Expr → Lean.MetaM (Lean.Meta.Simp.Arith.Nat.LinearExpr × Array Lean.Expr) |
IsLocalization.adjoin_inv | Mathlib.RingTheory.Localization.Away.AdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] (r : R), IsLocalization.Away r (AdjoinRoot (Polynomial.C r * Polynomial.X - 1)) |
WeierstrassCurve.Projective.baseChange_polynomialY | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {R : Type r} {S : Type s} {A : Type u} {B : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing A]
[inst_3 : CommRing B] {W' : WeierstrassCurve.Projective R} [inst_4 : Algebra R S] [inst_5 : Algebra R A]
[inst_6 : Algebra S A] [IsScalarTower R S A] [inst_8 : Algebra R B] [inst_9 : Algebra S B] [IsScalarTower R S B]
(f : A →ₐ[S] B),
(WeierstrassCurve.baseChange W' B).toProjective.polynomialY =
(MvPolynomial.map ↑f) (WeierstrassCurve.baseChange W' A).toProjective.polynomialY |
Lean.Linter.MissingDocs.lintNamed | Lean.Linter.MissingDocs | Lean.Syntax → String → Lean.Elab.Command.CommandElabM Unit |
_private.Lean.Elab.Tactic.Omega.Frontend.0.Lean.Elab.Tactic.Omega.asLinearComboImpl.handleNatCast.match_1 | Lean.Elab.Tactic.Omega.Frontend | (motive : Option Lean.Expr → Sort u_1) →
(__do_lift : Option Lean.Expr) →
((v : Lean.Expr) → motive (some v)) → ((x : Option Lean.Expr) → motive x) → motive __do_lift |
_private.Lean.Compiler.LCNF.ToDecl.0.Lean.Compiler.LCNF.macroInline._sparseCasesOn_1 | Lean.Compiler.LCNF.ToDecl | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t |
isExtrFilter_dual_iff | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : Preorder β] {f : α → β} {l : Filter α} {a : α},
IsExtrFilter (⇑OrderDual.toDual ∘ f) l a ↔ IsExtrFilter f l a |
BddLat.hasForgetToBddOrd._proof_1 | Mathlib.Order.Category.BddLat | ∀ (X : BddLat),
BddOrd.ofHom (BddLat.Hom.hom (CategoryTheory.CategoryStruct.id X)).toBoundedOrderHom =
CategoryTheory.CategoryStruct.id (BddOrd.of ↑X.toLat) |
AddHom.instAdd.eq_1 | Mathlib.Algebra.Group.Hom.Basic | ∀ {M : Type u_2} {N : Type u_3} [inst : Add M] [inst_1 : AddCommSemigroup N],
AddHom.instAdd = { add := fun f g => { toFun := fun m => f m + g m, map_add' := ⋯ } } |
CoalgCat.mk.noConfusion | Mathlib.Algebra.Category.CoalgCat.Basic | {R : Type u} →
{inst : CommRing R} →
{P : Sort u_1} →
{toModuleCat : ModuleCat R} →
{instCoalgebra : Coalgebra R ↑toModuleCat} →
{toModuleCat' : ModuleCat R} →
{instCoalgebra' : Coalgebra R ↑toModuleCat'} →
{ toModuleCat := toModuleCat, instCoalgebra := instCoalgebra } =
{ toModuleCat := toModuleCat', instCoalgebra := instCoalgebra' } →
(toModuleCat ≍ toModuleCat' → instCoalgebra ≍ instCoalgebra' → P) → P |
Prod.seminormedRing._proof_12 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : SeminormedRing α] [inst_1 : SeminormedRing β] (n : ℕ) (x : α × β),
Semiring.npow (n + 1) x = Semiring.npow n x * x |
Nat.div_ne_zero_iff_of_dvd | Init.Data.Nat.Lemmas | ∀ {b a : ℕ}, b ∣ a → (a / b ≠ 0 ↔ a ≠ 0 ∧ b ≠ 0) |
Lean.Widget.instEmptyCollectionInteractiveGoals | Lean.Widget.InteractiveGoal | EmptyCollection Lean.Widget.InteractiveGoals |
CategoryTheory.Functor.Faithful.div_comp | Mathlib.CategoryTheory.Functor.FullyFaithful | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C E) [F.Faithful]
(G : CategoryTheory.Functor D E) [inst_4 : G.Faithful] (obj : C → D) (h_obj : ∀ (X : C), G.obj (obj X) = F.obj X)
(map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)) (h_map : ∀ {X Y : C} {f : X ⟶ Y}, G.map (map f) ≍ F.map f),
(CategoryTheory.Functor.Faithful.div F G obj h_obj map h_map).comp G = F |
ModuleCat.Hom._sizeOf_1 | Mathlib.Algebra.Category.ModuleCat.Basic | {R : Type u} → {inst : Ring R} → {M N : ModuleCat R} → [SizeOf R] → M.Hom N → ℕ |
PseudoEpimorphismClass.recOn | Mathlib.Topology.Order.Hom.Esakia | {F : Type u_6} →
{α : Type u_7} →
{β : Type u_8} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
[inst_2 : FunLike F α β] →
{motive : PseudoEpimorphismClass F α β → Sort u} →
(t : PseudoEpimorphismClass F α β) →
([toRelHomClass : RelHomClass F (fun x1 x2 => x1 ≤ x2) fun x1 x2 => x1 ≤ x2] →
(exists_map_eq_of_map_le : ∀ (f : F) ⦃a : α⦄ ⦃b : β⦄, f a ≤ b → ∃ c, a ≤ c ∧ f c = b) → motive ⋯) →
motive t |
CategoryTheory.Subgroupoid.obj_surjective_of_im_eq_top | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] {D : Type u_1} [inst_1 : CategoryTheory.Groupoid D]
(φ : CategoryTheory.Functor C D) (hφ : Function.Injective φ.obj),
CategoryTheory.Subgroupoid.im φ hφ = ⊤ → Function.Surjective φ.obj |
NNRat.coe_pow._simp_1 | Mathlib.Data.NNRat.Defs | ∀ (q : ℚ≥0) (n : ℕ), ↑q ^ n = ↑(q ^ n) |
_private.Mathlib.LinearAlgebra.Matrix.ToLin.0.LinearMap.toMatrix_basis_equiv._simp_1_1 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) |
List.IsChain.backwards_cons_induction | Mathlib.Data.List.Chain | ∀ {α : Type u} {r : α → α → Prop} {a b : α} (p : α → Prop) (l : List α),
List.IsChain r (a :: l) → (a :: l).getLast ⋯ = b → (∀ ⦃x y : α⦄, r x y → p y → p x) → p b → ∀ i ∈ a :: l, p i |
NonUnitalAlgHom.Lmul._proof_4 | Mathlib.Analysis.Normed.Operator.Mul | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] (R : Type u_2) [inst_1 : NonUnitalSeminormedRing R]
[inst_2 : NormedSpace 𝕜 R], ContinuousConstSMul 𝕜 R |
CategoryTheory.Pretopology.trivial._proof_2 | Mathlib.CategoryTheory.Sites.Pretopology | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] ⦃X : C⦄ (S : CategoryTheory.Presieve X)
(Ti : ⦃Y : C⦄ → (f : Y ⟶ X) → S f → CategoryTheory.Presieve Y),
S ∈ {S | ∃ Y f, ∃ (_ : CategoryTheory.IsIso f), S = CategoryTheory.Presieve.singleton f} →
(∀ ⦃Y : C⦄ (f : Y ⟶ X) (H : S f),
Ti f H ∈ {S | ∃ Y_1 f, ∃ (_ : CategoryTheory.IsIso f), S = CategoryTheory.Presieve.singleton f}) →
S.bind Ti ∈ {S | ∃ Y f, ∃ (_ : CategoryTheory.IsIso f), S = CategoryTheory.Presieve.singleton f} |
Module.Relations.solutionFinsupp._proof_1 | Mathlib.Algebra.Module.Presentation.Free | ∀ {A : Type u_1} [inst : Ring A] (relations : Module.Relations A) [IsEmpty relations.R] (r : relations.R),
(Finsupp.linearCombination A fun g => fun₀ | g => 1) (relations.relation r) = 0 |
CategoryTheory.Limits.PreservesFiniteLimitsOfIsFilteredCostructuredArrowYonedaAux.flipFunctorToInterchange_inv_app_app | Mathlib.CategoryTheory.Limits.Preserves.Presheaf | ∀ {C : Type u} [inst : CategoryTheory.SmallCategory C] (A : CategoryTheory.Functor Cᵒᵖ (Type u)) {J : Type}
[inst_1 : CategoryTheory.SmallCategory J] (K : CategoryTheory.Functor J Cᵒᵖ)
(X : CategoryTheory.CostructuredArrow CategoryTheory.yoneda A) (X_1 : J)
(a :
((CategoryTheory.Limits.PreservesFiniteLimitsOfIsFilteredCostructuredArrowYonedaAux.functorToInterchange A
K).flip.obj
X).obj
X_1),
((CategoryTheory.Limits.PreservesFiniteLimitsOfIsFilteredCostructuredArrowYonedaAux.flipFunctorToInterchange A
K).inv.app
X).app
X_1 a =
a |
CategoryTheory.MorphismProperty.epimorphisms.iff._simp_1 | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.MorphismProperty.epimorphisms C f = CategoryTheory.Epi f |
OrderRingHom.apply_eq_self | Mathlib.Algebra.Order.Archimedean.Hom | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] [Archimedean α] (f : α →+*o α)
(x : α), f x = x |
SheafOfModules.evaluationPreservesLimitsOfSize | Mathlib.Algebra.Category.ModuleCat.Sheaf.Limits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
(R : CategoryTheory.Sheaf J RingCat) (X : Cᵒᵖ),
CategoryTheory.Limits.PreservesLimitsOfSize.{v₂, v, max u₁ v, v, max (max (max u u₁) (v + 1)) v₁, max u (v + 1)}
(SheafOfModules.evaluation R X) |
RelIso.emptySumLex_apply | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} (r : α → α → Prop) (s : β → β → Prop) [inst : IsEmpty α] (a : α ⊕ β),
(RelIso.emptySumLex r s) a = (Equiv.sumEmpty β α) a.swap |
ContinuousLinearMap.semiring._proof_15 | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {R₁ : Type u_1} [inst : Semiring R₁] {M₁ : Type u_2} [inst_1 : TopologicalSpace M₁] [inst_2 : AddCommMonoid M₁]
[inst_3 : Module R₁ M₁] (x : M₁ →L[R₁] M₁), Monoid.npow 0 x = 1 |
_private.Mathlib.Probability.Moments.Variance.0.ProbabilityTheory.evariance_eq_zero_iff._simp_1_2 | Mathlib.Probability.Moments.Variance | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) |
cfcₙ_smul._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax |
NonUnitalCommCStarAlgebra.recOn | Mathlib.Analysis.CStarAlgebra.Classes | {A : Type u_1} →
{motive : NonUnitalCommCStarAlgebra A → Sort u} →
(t : NonUnitalCommCStarAlgebra A) →
([toNonUnitalNormedCommRing : NonUnitalNormedCommRing A] →
[toStarRing : StarRing A] →
[toCompleteSpace : CompleteSpace A] →
[toCStarRing : CStarRing A] →
[toNormedSpace : NormedSpace ℂ A] →
[toIsScalarTower : IsScalarTower ℂ A A] →
[toSMulCommClass : SMulCommClass ℂ A A] →
[toStarModule : StarModule ℂ A] →
motive
{ toNonUnitalNormedCommRing := toNonUnitalNormedCommRing, toStarRing := toStarRing,
toCompleteSpace := toCompleteSpace, toCStarRing := toCStarRing,
toNormedSpace := toNormedSpace, toIsScalarTower := toIsScalarTower,
toSMulCommClass := toSMulCommClass, toStarModule := toStarModule }) →
motive t |
IsDedekindDomain.HeightOneSpectrum.adicAbv._proof_1 | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] {K : Type u_2} [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R) {b : NNReal}
(hb : 1 < b) (x : K), 0 ≤ ↑(v.adicAbvDef hb x) |
Nat.dvd_of_mem_primeFactorsList | Mathlib.Data.Nat.Factors | ∀ {n p : ℕ}, p ∈ n.primeFactorsList → p ∣ n |
_private.Mathlib.LinearAlgebra.Finsupp.Span.0.Finsupp.iInf_ker_lapply_le_bot._simp_1_2 | Mathlib.LinearAlgebra.Finsupp.Span | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Sort u_4}
(p : ι → Submodule R M) {x : M}, (x ∈ ⨅ i, p i) = ∀ (i : ι), x ∈ p i |
Std.LinearPreorderPackage.le_total | Init.Data.Order.PackageFactories | ∀ {α : Type u} [self : Std.LinearPreorderPackage α] (a b : α), a ≤ b ∨ b ≤ a |
_private.Mathlib.Algebra.Lie.Semisimple.Basic.0.LieAlgebra.IsSemisimple.isSimple_of_isAtom._simp_1_15 | Mathlib.Algebra.Lie.Semisimple.Basic | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) |
_private.Lean.Compiler.LCNF.LiveVars.0.Lean.Compiler.LCNF.State.rec | Lean.Compiler.LCNF.LiveVars | {motive : Lean.Compiler.LCNF.State✝ → Sort u} →
((visitedJps : Lean.FVarIdHashSet) → motive { visitedJps := visitedJps }) →
(t : Lean.Compiler.LCNF.State✝¹) → motive t |
Complex.norm_log_one_add_sub_self_le | Mathlib.Analysis.SpecialFunctions.Complex.LogBounds | ∀ {z : ℂ}, ‖z‖ < 1 → ‖Complex.log (1 + z) - z‖ ≤ ‖z‖ ^ 2 * (1 - ‖z‖)⁻¹ / 2 |
AddCommute.addUnits_neg_right | Mathlib.Algebra.Group.Commute.Units | ∀ {M : Type u_1} [inst : AddMonoid M] {a : M} {u : AddUnits M}, AddCommute a ↑u → AddCommute a ↑(-u) |
_private.Mathlib.Tactic.Linter.UnusedTactic.0.Mathlib.Linter.UnusedTactic.eraseUsedTactics | Mathlib.Tactic.Linter.UnusedTactic | Std.HashSet Lean.SyntaxNodeKind → Lean.Elab.InfoTree → Mathlib.Linter.UnusedTactic.M✝ Unit |
Bornology.IsBounded.snd_of_prod | Mathlib.Topology.Bornology.Constructions | ∀ {α : Type u_1} {β : Type u_2} [inst : Bornology α] [inst_1 : Bornology β] {s : Set α} {t : Set β},
Bornology.IsBounded (s ×ˢ t) → s.Nonempty → Bornology.IsBounded t |
continuous_sigmaMk | Mathlib.Topology.Constructions | ∀ {ι : Type u_5} {σ : ι → Type u_7} [inst : (i : ι) → TopologicalSpace (σ i)] {i : ι}, Continuous (Sigma.mk i) |
PadicInt.toZMod._proof_2 | Mathlib.NumberTheory.Padics.RingHoms | ∀ {p : ℕ} [hp_prime : Fact (Nat.Prime p)] (x : ℤ_[p]) (a b : ℕ),
x - ↑a ∈ Ideal.span {↑p} → x - ↑b ∈ Ideal.span {↑p} → ↑a = ↑b |
Lean.Elab.Tactic.evalDone._regBuiltin.Lean.Elab.Tactic.evalDone.declRange_3 | Lean.Elab.Tactic.BuiltinTactic | IO Unit |
_private.Mathlib.RingTheory.Algebraic.Defs.0.Algebra.isAlgebraic_iff._simp_1_3 | Mathlib.RingTheory.Algebraic.Defs | ∀ {p : Prop} {q : p → Prop} (h : p), (∀ (h' : p), q h') = q h |
_private.Lean.Elab.LetRec.0.Lean.Elab.Term.mkLetRecDeclView | Lean.Elab.LetRec | Lean.Syntax → Lean.Elab.TermElabM Lean.Elab.Term.LetRecView |
Vector.swap._auto_3 | Init.Data.Vector.Basic | Lean.Syntax |
WithVal.instNumberField | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {R : Type u_1} {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : Field R] (v : Valuation R Γ₀)
[NumberField R], NumberField (WithVal v) |
Topology.IsEmbedding.comp | Mathlib.Topology.Maps.Basic | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {f : X → Y} {g : Y → Z} [inst : TopologicalSpace X]
[inst_1 : TopologicalSpace Y] [inst_2 : TopologicalSpace Z],
Topology.IsEmbedding g → Topology.IsEmbedding f → Topology.IsEmbedding (g ∘ f) |
IsOpen.stronglyLocallyContractibleSpace | Mathlib.Topology.Homotopy.LocallyContractible | ∀ {X : Type u_1} [inst : TopologicalSpace X] [StronglyLocallyContractibleSpace X] {U : Set X},
IsOpen U → StronglyLocallyContractibleSpace ↑U |
ModuleCat.CoextendScalars.map' | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | {R : Type u₁} →
{S : Type u₂} →
[inst : Ring R] →
[inst_1 : Ring S] →
(f : R →+* S) →
{M M' : ModuleCat R} → (M ⟶ M') → (ModuleCat.CoextendScalars.obj' f M ⟶ ModuleCat.CoextendScalars.obj' f M') |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.getMatchEqCondForAux | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums | Lean.Name → Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind → Lean.MetaM Lean.Name |
Equiv.prodEmbeddingDisjointEquivSigmaEmbeddingRestricted._proof_1 | Mathlib.Logic.Equiv.Embedding | ∀ {α : Type u_3} {β : Type u_1} {γ : Type u_2} (a : α ↪ γ),
(fun b => Disjoint (Set.range ⇑a) (Set.range ⇑b)) = fun f => ∀ (a_1 : β), f a_1 ∈ (Set.range ⇑a)ᶜ |
Ordinal.lt_one_iff_zero | Mathlib.SetTheory.Ordinal.Basic | ∀ {a : Ordinal.{u_1}}, a < 1 ↔ a = 0 |
_private.Mathlib.Logic.Equiv.Prod.0.Equiv.piEquivPiSubtypeProd._proof_7 | Mathlib.Logic.Equiv.Prod | ∀ {α : Type u_2} (p : α → Prop) (β : α → Type u_1) [inst : DecidablePred p] (f : (i : { x // p x }) → β ↑i)
(g : (i : { x // ¬p x }) → β ↑i),
(fun x => if h : p ↑x then (f, g).1 ⟨↑x, h⟩ else (f, g).2 ⟨↑x, h⟩, fun x =>
if h : p ↑x then (f, g).1 ⟨↑x, h⟩ else (f, g).2 ⟨↑x, h⟩).1 =
(f, g).1 |
Eq.trans_ssubset | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : HasSSubset α] {a b c : α}, a = b → b ⊂ c → a ⊂ c |
Std.DTreeMap.isEmpty | Std.Data.DTreeMap.Basic | {α : Type u} → {β : α → Type v} → {cmp : α → α → Ordering} → Std.DTreeMap α β cmp → Bool |
Lean.Elab.Tactic.BVDecide.Frontend.M.simplifyTernaryProof | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect | (Lean.Expr → Lean.Expr) →
Lean.Expr →
Option Lean.Expr →
Lean.Expr → Option Lean.Expr → Lean.Expr → Option Lean.Expr → Option (Lean.Expr × Lean.Expr × Lean.Expr) |
CategoryTheory.PreOneHypercover.Hom.ext'_iff | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} {f g : E.Hom F},
f = g ↔
∃ (hs₀ : f.s₀ = g.s₀) (_ :
∀ (i : E.I₀), f.h₀ i = CategoryTheory.CategoryStruct.comp (g.h₀ i) (CategoryTheory.eqToHom ⋯)) (hs₁ :
∀ (i j : E.I₀) (k : E.I₁ i j), f.s₁ k = (CategoryTheory.PreOneHypercover.congrIndexOneOfEq ⋯ ⋯) (g.s₁ k)),
∀ (i j : E.I₀) (k : E.I₁ i j),
f.h₁ k =
CategoryTheory.CategoryStruct.comp (g.h₁ k)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.PreOneHypercover.congrIndexOneOfEqIso ⋯ ⋯ (g.s₁ k)).inv
(CategoryTheory.eqToHom ⋯)) |
Set.projIcc_of_le_left | Mathlib.Order.Interval.Set.ProjIcc | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α} (h : a ≤ b) {x : α}, x ≤ a → Set.projIcc a b h x = ⟨a, ⋯⟩ |
CategoryTheory.Category.comp_id._autoParam | Mathlib.CategoryTheory.Category.Basic | Lean.Syntax |
Std.DHashMap.Internal.Raw₀.getEntry?_eq_getEntry? | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [PartialEquivBEq α] [LawfulHashable α]
{m : Std.DHashMap.Internal.Raw₀ α β},
Std.DHashMap.Internal.Raw.WFImp ↑m →
∀ {a : α}, m.getEntry? a = Std.Internal.List.getEntry? a (Std.DHashMap.Internal.toListModel (↑m).buckets) |
Std.Format.bracket | Init.Data.Format.Basic | String → Std.Format → String → Std.Format |
Lean.Meta.Grind.Context.cheapCases._default | Lean.Meta.Tactic.Grind.Types | Bool |
linearIndependent_fin_cons | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {K : Type u_3} {V : Type u} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {x : V} {n : ℕ}
{v : Fin n → V}, LinearIndependent K (Fin.cons x v) ↔ LinearIndependent K v ∧ x ∉ Submodule.span K (Set.range v) |
WeierstrassCurve.Projective.PointClass | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | (R : Type r) → [CommRing R] → Type r |
eq_zero_or_one_of_sq_eq_self | Mathlib.Algebra.GroupWithZero.Defs | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] [IsRightCancelMulZero M₀] {x : M₀}, x ^ 2 = x → x = 0 ∨ x = 1 |
IsOpen.add_closure | Mathlib.Topology.Algebra.Group.Pointwise | ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [IsTopologicalAddGroup G] {s : Set G},
IsOpen s → ∀ (t : Set G), s + closure t = s + t |
Set.IsWF.min_add | Mathlib.Data.Finset.MulAntidiagonal | ∀ {α : Type u_1} {s t : Set α} [inst : AddCommMonoid α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedCancelAddMonoid α]
(hs : s.IsWF) (ht : t.IsWF) (hsn : s.Nonempty) (htn : t.Nonempty), ⋯.min ⋯ = hs.min hsn + ht.min htn |
Order.not_isSuccLimit_add_one | Mathlib.Algebra.Order.SuccPred | ∀ {α : Type u_1} [inst : PartialOrder α] (a : α) [inst_1 : Add α] [inst_2 : One α] [SuccAddOrder α] [NoMaxOrder α],
¬Order.IsSuccLimit (a + 1) |
UInt16.pow | Init.Data.UInt.Basic | UInt16 → ℕ → UInt16 |
ModuleCat.smulNatTrans._proof_8 | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ (R : Type u_1) [inst : Ring R] (x x_1 : R),
{ app := fun M => M.smul (x * x_1), naturality := ⋯ } =
{ app := fun M => M.smul x, naturality := ⋯ } * { app := fun M => M.smul x_1, naturality := ⋯ } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.