name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Monoid.CoprodI.NeWord.head.eq_2 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] (x x_1 j k : ι) (_hne : j ≠ k)
(w₁ : Monoid.CoprodI.NeWord M x j) (w₂ : Monoid.CoprodI.NeWord M k x_1), (w₁.append _hne w₂).head = w₁.head |
UniqueProds.casesOn | Mathlib.Algebra.Group.UniqueProds.Basic | {G : Type u_1} →
[inst : Mul G] →
{motive : UniqueProds G → Sort u} →
(t : UniqueProds G) →
((uniqueMul_of_nonempty :
∀ {A B : Finset G}, A.Nonempty → B.Nonempty → ∃ a0 ∈ A, ∃ b0 ∈ B, UniqueMul A B a0 b0) →
motive ⋯) →
motive t |
Lean.Meta.Grind.EMatchTheoremPtr | Lean.Meta.Tactic.Grind.EMatchTheoremPtr | Type |
Set.Ici.coe_sup._simp_1 | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} [inst : SemilatticeSup α] {a : α} {x y : ↑(Set.Ici a)}, ↑x ⊔ ↑y = ↑(x ⊔ y) |
_private.Init.Data.String.Defs.0.String.utf8ByteSize_eq_zero_iff._simp_1_1 | Init.Data.String.Defs | ∀ {s t : String}, (s = t) = (s.toByteArray = t.toByteArray) |
FirstOrder.Language.Relations.formula₂.eq_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {α : Type u'} (r : L.Relations 2) (t₁ t₂ : L.Term α), r.formula₂ t₁ t₂ = r.formula ![t₁, t₂] |
Lean.Compiler.LCNF.Simp.simpProj? | Lean.Compiler.LCNF.Simp.SimpValue | Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure →
OptionT Lean.Compiler.LCNF.Simp.SimpM (Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure) |
MeasureTheory.Lp.zero_smul | Mathlib.MeasureTheory.Function.Holder | ∀ {α : Type u_1} (𝕜 : Type u_3) {E : Type u_4} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (p : ENNReal)
{q r : ENNReal} [hpqr : p.HolderTriple q r] [inst : NormedRing 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : Module 𝕜 E] [inst_3 : IsBoundedSMul 𝕜 E] (f : ↥(MeasureTheory.Lp E q μ)), 0 • f = 0 |
_private.Init.Data.AC.0.Lean.Data.AC.removeNeutrals.loop.match_1.eq_1 | Init.Data.AC | ∀ (motive : Bool → Sort u_1) (h_1 : Unit → motive true) (h_2 : Unit → motive false),
(match true with
| true => h_1 ()
| false => h_2 ()) =
h_1 () |
_private.Lean.Compiler.ExportAttr.0.Lean.isValidCppName | Lean.Compiler.ExportAttr | Lean.Name → Bool |
AlgebraicGeometry.Scheme.OpenCover.pullbackCoverAffineRefinementObjIso_inv_pullbackHom_assoc | Mathlib.AlgebraicGeometry.Cover.Open | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (𝒰 : Y.OpenCover)
(i : (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰.affineRefinement.openCover).I₀)
{Z : AlgebraicGeometry.Scheme} (h : 𝒰.affineRefinement.openCover.X i ⟶ Z),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.OpenCover.pullbackCoverAffineRefinementObjIso f 𝒰 i).inv
(CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Cover.pullbackHom 𝒰.affineRefinement.openCover f i)
h) =
CategoryTheory.CategoryStruct.comp
(AlgebraicGeometry.Scheme.Cover.pullbackHom (𝒰.X i.fst).affineCover
(AlgebraicGeometry.Scheme.Cover.pullbackHom 𝒰 f i.fst) i.snd)
h |
CategoryTheory.Limits.pullbackRightPullbackFstIso_hom_snd_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) (f' : W ⟶ X)
[inst_1 : CategoryTheory.Limits.HasPullback f g]
[inst_2 : CategoryTheory.Limits.HasPullback f' (CategoryTheory.Limits.pullback.fst f g)] {Z_1 : C} (h : Y ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullbackRightPullbackFstIso f g f').hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.snd (CategoryTheory.CategoryStruct.comp f' f) g) h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.snd f' (CategoryTheory.Limits.pullback.fst f g))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.snd f g) h) |
_private.Mathlib.RingTheory.HahnSeries.Basic.0.HahnSeries.ext.match_1 | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_2} {inst : PartialOrder Γ} {inst_1 : Zero R} (motive : HahnSeries Γ R → Prop)
(h : HahnSeries Γ R),
(∀ (coeff : Γ → R) (isPWO_support' : (Function.support coeff).IsPWO),
motive { coeff := coeff, isPWO_support' := isPWO_support' }) →
motive h |
MeasureTheory.Measure.IsOpenPosMeasure.mk | Mathlib.MeasureTheory.Measure.OpenPos | ∀ {X : Type u_1} [inst : TopologicalSpace X] {m : MeasurableSpace X} {μ : MeasureTheory.Measure X},
(∀ (U : Set X), IsOpen U → U.Nonempty → μ U ≠ 0) → μ.IsOpenPosMeasure |
Denumerable.nat | Mathlib.Logic.Denumerable | Denumerable ℕ |
groupHomology.single_isCycle₁_of_mem_fixedPoints | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {G : Type u_1} {A : Type u_2} [inst : Group G] [inst_1 : AddCommGroup A] [inst_2 : DistribMulAction G A] (g : G),
∀ a ∈ MulAction.fixedPoints G A, groupHomology.IsCycle₁ fun₀ | g => a |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.EqCnstr.0.Lean.Meta.Grind.Arith.CommRing.toRingExpr?.match_1 | Lean.Meta.Tactic.Grind.Arith.CommRing.EqCnstr | (motive : Option Lean.Grind.CommRing.Var → Sort u_1) →
(x : Option Lean.Grind.CommRing.Var) →
((x : Lean.Grind.CommRing.Var) → motive (some x)) → ((x : Option Lean.Grind.CommRing.Var) → motive x) → motive x |
_private.Init.Data.Option.Monadic.0.Option.instForIn'InferInstanceMembershipOfMonad.match_1.eq_1 | Init.Data.Option.Monadic | ∀ {β : Type u_1} (motive : ForInStep β → Sort u_2) (r : β) (h_1 : (r : β) → motive (ForInStep.done r))
(h_2 : (r : β) → motive (ForInStep.yield r)),
(match ForInStep.done r with
| ForInStep.done r => h_1 r
| ForInStep.yield r => h_2 r) =
h_1 r |
_private.Init.Data.Int.LemmasAux.0.Int.ble'_eq_true._proof_1_2 | Init.Data.Int.LemmasAux | ∀ (a a_1 : ℕ), ¬Int.negSucc a_1 < ↑a → False |
LightCondensed.finYoneda._proof_1 | Mathlib.Condensed.Discrete.Colimit | ∀ (F : CategoryTheory.Functor LightProfiniteᵒᵖ (Type u_1)) (X : FintypeCatᵒᵖ),
(fun g => g ∘ ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X).unop)) =
CategoryTheory.CategoryStruct.id
((Opposite.unop X).carrier →
F.obj (FintypeCat.toLightProfinite.op.obj (Opposite.op { carrier := PUnit.{u_1 + 1}, str := PUnit.fintype }))) |
submonoidOfIdempotent._proof_1 | Mathlib.GroupTheory.OrderOfElement | ∀ {M : Type u_1} [inst : LeftCancelMonoid M] (S : Set M), S * S = S → ∀ a ∈ S, ∀ (n : ℕ), a ^ (n + 1) ∈ S |
RootPairing.exist_set_root_not_disjoint_and_le_ker_coroot'_of_invtSubmodule | Mathlib.LinearAlgebra.RootSystem.Irreducible | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) [NeZero 2]
[IsDomain R] [Module.IsTorsionFree R M] (q : Submodule R M),
(∀ (i : ι), q ∈ Module.End.invtSubmodule ↑(P.reflection i)) →
∃ Φ, (∀ i ∈ Φ, ¬Disjoint q (R ∙ P.root i)) ∧ ∀ i ∉ Φ, q ≤ LinearMap.ker (P.coroot' i) |
_private.Mathlib.RingTheory.FiniteType.0.AddMonoidAlgebra.finiteType_iff_fg._simp_1_1 | Mathlib.RingTheory.FiniteType | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x : M},
(x ∈ ⊤) = True |
SimpleGraph.Walk.IsPath.of_append_left | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u v w : V} {p : G.Walk u v} {q : G.Walk v w}, (p.append q).IsPath → p.IsPath |
Lean.mkIntDvd | Lean.Expr | Lean.Expr → Lean.Expr → Lean.Expr |
MulActionHom.comp_inverse' | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [inst : SMul M X] {Y : Type u_6} [inst_1 : SMul N Y]
{φ' : N → M} {f : X →ₑ[φ] Y} {g : Y → X} {k₁ : Function.LeftInverse φ' φ} {k₂ : Function.RightInverse φ' φ}
{h₁ : Function.LeftInverse g ⇑f} {h₂ : Function.RightInverse g ⇑f}, (f.inverse' g k₂ h₁ h₂).comp f = MulActionHom.id M |
eVariationOn.eVariationOn_inter_Ioi_eq_inter_Ici_of_continuousWithinAt | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] {E : Type u_2} [inst_1 : PseudoEMetricSpace E] [inst_2 : TopologicalSpace α]
[OrderTopology α] {f : α → E} {s : Set α} {a : α},
(nhdsWithin a (s ∩ Set.Ioi a)).NeBot →
ContinuousWithinAt f (s ∩ Set.Ici a) a → eVariationOn f (s ∩ Set.Ioi a) = eVariationOn f (s ∩ Set.Ici a) |
Finset.addEnergy_pos | Mathlib.Combinatorics.Additive.Energy | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Add α] {s t : Finset α}, s.Nonempty → t.Nonempty → 0 < s.addEnergy t |
ModuleCat.hom_surjective | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u} [inst : Ring R] {M N : ModuleCat R}, Function.Surjective ModuleCat.Hom.hom |
Matroid.IsCircuit.eq_of_superset_isCircuit | Mathlib.Combinatorics.Matroid.Circuit | ∀ {α : Type u_1} {M : Matroid α} {C C' : Set α}, M.IsCircuit C → M.IsCircuit C' → C' ⊆ C → C = C' |
Lean.Core.SavedState.messages._inherited_default | Lean.CoreM | Lean.MessageLog |
Algebra.ctorIdx | Mathlib.Algebra.Algebra.Defs | {R : Type u} → {A : Type v} → {inst : CommSemiring R} → {inst_1 : Semiring A} → Algebra R A → ℕ |
CategoryTheory.GrothendieckTopology.Cover.Arrow.precompRelation._proof_2 | Mathlib.CategoryTheory.Sites.Grothendieck | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} {J : CategoryTheory.GrothendieckTopology C}
{S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id (I.precomp g).Y) (I.precomp g).f =
CategoryTheory.CategoryStruct.comp g I.f |
Locale.localePointOfSpacePoint._proof_3 | Mathlib.Topology.Order.Category.FrameAdjunction | ∀ (X : Type u_1) [inst : TopologicalSpace X] (x : X), (x ∈ ⊤) = (x ∈ ⊤) |
IsDivSequence | Mathlib.NumberTheory.EllipticDivisibilitySequence | {R : Type u} → [CommRing R] → (ℤ → R) → Prop |
_private.Mathlib.Analysis.Complex.Norm.0.Complex.abs_re_div_norm_le_one._simp_1_1 | Mathlib.Analysis.Complex.Norm | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : LE α] [ZeroLEOneClass α], (0 ≤ 1) = True |
Convex.openSegment_interior_closure_subset_interior | Mathlib.Analysis.Convex.Topology | ∀ {𝕜 : Type u_2} {E : Type u_3} [inst : Field 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] [inst_4 : TopologicalSpace E] [IsTopologicalAddGroup E] [ContinuousConstSMul 𝕜 E] {s : Set E},
Convex 𝕜 s → ∀ {x y : E}, x ∈ interior s → y ∈ closure s → openSegment 𝕜 x y ⊆ interior s |
Order.PFilter.infGi | Mathlib.Order.PFilter | {P : Type u_1} →
[inst : CompleteSemilatticeInf P] →
GaloisCoinsertion (fun x => OrderDual.toDual (Order.PFilter.principal x)) fun F => sInf ↑(OrderDual.ofDual F) |
CategoryTheory.Functor.whiskerRight | Mathlib.CategoryTheory.Whiskering | {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] →
{G H : CategoryTheory.Functor C D} → (G ⟶ H) → (F : CategoryTheory.Functor D E) → G.comp F ⟶ H.comp F |
OrderHom.instFunLike._proof_1 | Mathlib.Order.Hom.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (f g : α →o β), f.toFun = g.toFun → f = g |
Std.DTreeMap.Internal.Impl.contains_inter_eq_false_of_contains_eq_false_right | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
(h₁ : m₁.WF),
m₂.WF →
∀ {k : α},
Std.DTreeMap.Internal.Impl.contains k m₂ = false → Std.DTreeMap.Internal.Impl.contains k (m₁.inter m₂ ⋯) = false |
CategoryTheory.ShortComplex.HomologyData.ofIso._proof_2 | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂), CategoryTheory.IsIso e.hom.τ₂ |
Equiv.ofIff._proof_2 | Mathlib.Logic.Equiv.Defs | ∀ {P Q : Prop} (h : P ↔ Q) (x : P), ⋯ = ⋯ |
CategoryTheory.whiskeringLeftCompEvaluation_inv_app | Mathlib.CategoryTheory.Products.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor A B) (a : A)
(X : CategoryTheory.Functor B C),
(CategoryTheory.whiskeringLeftCompEvaluation F a).inv.app X = CategoryTheory.CategoryStruct.id (X.obj (F.obj a)) |
Lean.Meta.Sym.Offset.recOn | Lean.Meta.Sym.Offset | {motive : Lean.Meta.Sym.Offset → Sort u} →
(t : Lean.Meta.Sym.Offset) →
((k : ℕ) → motive (Lean.Meta.Sym.Offset.num k)) →
((e : Lean.Expr) → (k : ℕ) → motive (Lean.Meta.Sym.Offset.add e k)) → motive t |
_private.Mathlib.Analysis.Complex.Exponential.0.Real.exp_approx_end._simp_1_2 | Mathlib.Analysis.Complex.Exponential | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False |
Topology.WithGeneratedByTopology.instTopologicalSpace | Mathlib.Topology.Convenient.GeneratedBy | {ι : Type t} →
{X : ι → Type u} →
[inst : (i : ι) → TopologicalSpace (X i)] →
{Y : Type v} → [inst_1 : TopologicalSpace Y] → TopologicalSpace (Topology.WithGeneratedByTopology X Y) |
CategoryTheory.ObjectProperty.instIsClosedUnderColimitsOfShapeOppositeOpOfIsClosedUnderLimitsOfShape | Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.ObjectProperty C) (J : Type u')
[inst_1 : CategoryTheory.Category.{v', u'} J] [P.IsClosedUnderLimitsOfShape J], P.op.IsClosedUnderColimitsOfShape Jᵒᵖ |
Lean.Parser.Command.catBehaviorBoth | Lean.Parser.Syntax | Lean.Parser.Parser |
MeasureTheory.Measure.haveLebesgueDecomposition_add | Mathlib.MeasureTheory.Measure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} (μ ν : MeasureTheory.Measure α) [μ.HaveLebesgueDecomposition ν],
μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν) |
Inner.noConfusion | Mathlib.Analysis.InnerProductSpace.Defs | {P : Sort u} →
{𝕜 : Type u_4} →
{E : Type u_5} →
{t : Inner 𝕜 E} →
{𝕜' : Type u_4} → {E' : Type u_5} → {t' : Inner 𝕜' E'} → 𝕜 = 𝕜' → E = E' → t ≍ t' → Inner.noConfusionType P t t' |
CategoryTheory.Localization.Preadditive.add'_map | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Preadditive | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Preadditive C]
{L : CategoryTheory.Functor C D} (W : CategoryTheory.MorphismProperty C) [inst_3 : L.IsLocalization W]
[inst_4 : W.HasLeftCalculusOfFractions] {X Y : C} (f₁ f₂ : X ⟶ Y),
CategoryTheory.Localization.Preadditive.add' W (L.map f₁) (L.map f₂) = L.map (f₁ + f₂) |
Std.CancellationToken.State.mk | Std.Sync.CancellationToken | Option Std.CancellationReason → Std.Queue Std.CancellationToken.Consumer → Std.CancellationToken.State |
Set.exists_ne_of_one_lt_ncard | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α}, 1 < s.ncard → ∀ (a : α), ∃ b ∈ s, b ≠ a |
Preorder.toGradeBoundedOrder._proof_1 | Mathlib.Order.Grade | ∀ {α : Type u_1} [inst : Preorder α] (x x_1 : α), x ⋖ x_1 → x ⋖ x_1 |
Lean.Elab.Tactic.Do.addMData | Lean.Elab.Tactic.Do.LetElim | Lean.MData → Lean.Expr → Lean.Expr |
AddConstMap.instAddConstMapClass | Mathlib.Algebra.AddConstMap.Basic | ∀ {G : Type u_1} {H : Type u_2} [inst : Add G] [inst_1 : Add H] {a : G} {b : H},
AddConstMapClass (AddConstMap G H a b) G H a b |
Ultrafilter.comap._proof_1 | Mathlib.Order.Filter.Ultrafilter.Defs | ∀ {α : Type u_1} {β : Type u_2} {m : α → β} (u : Ultrafilter β), Set.range m ∈ u → (Filter.comap m ↑u).NeBot |
Lean.Grind.CommRing.Expr.toPolyC.go._sparseCasesOn_1 | Init.Grind.Ring.CommSolver | {motive : Lean.Grind.CommRing.Expr → Sort u} →
(t : Lean.Grind.CommRing.Expr) →
((k : ℤ) → motive (Lean.Grind.CommRing.Expr.num k)) →
((i : Lean.Grind.CommRing.Var) → motive (Lean.Grind.CommRing.Expr.var i)) →
(Nat.hasNotBit 9 t.ctorIdx → motive t) → motive t |
_private.Lean.DocString.Formatter.0.Lean.Doc.Parser.versoSyntaxToString | Lean.DocString.Formatter | Lean.Syntax → String |
Lean.Meta.DefEqCacheKind.transient | Lean.Meta.ExprDefEq | Lean.Meta.DefEqCacheKind |
List.headI_dedup | Mathlib.Data.List.Dedup | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Inhabited α] (l : List α),
l.dedup.headI = if l.headI ∈ l.tail then l.tail.dedup.headI else l.headI |
WithLp.prod_dist_eq_of_L2 | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ {α : Type u_2} {β : Type u_3} [inst : SeminormedAddCommGroup α] [inst_1 : SeminormedAddCommGroup β]
(x y : WithLp 2 (α × β)), dist x y = √(dist x.fst y.fst ^ 2 + dist x.snd y.snd ^ 2) |
Pi.constAlgHom._proof_4 | Mathlib.Algebra.Algebra.Pi | ∀ (A : Type u_1) (B : Type u_2) [inst : Semiring B] (x y : B),
(↑↑(Pi.constRingHom A B)).toFun (x + y) = (↑↑(Pi.constRingHom A B)).toFun x + (↑↑(Pi.constRingHom A B)).toFun y |
_private.Mathlib.RingTheory.PicardGroup.0.Module.Invertible.bijective_self_of_surjective._simp_1_2 | Mathlib.RingTheory.PicardGroup | ∀ {α : Type u_9} [inst : Mul α] (a b : α), a * b = a • b |
Matrix.vecMulBilin | Mathlib.LinearAlgebra.Matrix.ToLin | {m : Type u_2} →
{n : Type u_3} →
(R : Type u_4) →
(S : Type u_5) →
{A : Type u_6} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
[inst_2 : NonUnitalNonAssocSemiring A] →
[inst_3 : Module R A] →
[inst_4 : Module S A] →
[inst_5 : SMulCommClass S R A] →
[SMulCommClass S A A] →
[IsScalarTower R A A] → [Fintype m] → (m → A) →ₗ[R] Matrix m n A →ₗ[S] n → A |
OrderDual.instDistribMulAction' | Mathlib.Algebra.Order.GroupWithZero.Action.Synonym | {G₀ : Type u_1} →
{M₀ : Type u_2} → [inst : Monoid G₀] → [inst_1 : AddMonoid M₀] → [DistribMulAction G₀ M₀] → DistribMulAction G₀ M₀ᵒᵈ |
ContravariantClass | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | (M : Type u_1) → (N : Type u_2) → (M → N → N) → (N → N → Prop) → Prop |
Module.Free.rank_eq_card_chooseBasisIndex | Mathlib.LinearAlgebra.Dimension.Free | ∀ (R : Type u) (M : Type v) [inst : Semiring R] [StrongRankCondition R] [inst_2 : AddCommMonoid M] [inst_3 : Module R M]
[inst_4 : Module.Free R M], Module.rank R M = Cardinal.mk (Module.Free.ChooseBasisIndex R M) |
CategoryTheory.Functor.leibnizPushout._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u_6} {C₂ : Type u_4} {C₃ : Type u_2} [inst : CategoryTheory.Category.{u_5, u_6} C₁]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C₂] [inst_2 : CategoryTheory.Category.{u_1, u_2} C₃]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)) [CategoryTheory.Limits.HasPushouts C₃]
(f₁ : CategoryTheory.Arrow C₁) (f₂ : CategoryTheory.Arrow C₂),
CategoryTheory.Limits.HasColimit
(CategoryTheory.Limits.span ((F.map f₁.hom).app ((CategoryTheory.Functor.id C₂).obj f₂.left))
((F.obj ((CategoryTheory.Functor.id C₁).obj f₁.left)).map f₂.hom)) |
equicontinuousOn_finite | Mathlib.Topology.UniformSpace.Equicontinuity | ∀ {ι : Type u_1} {X : Type u_3} {α : Type u_6} [tX : TopologicalSpace X] [uα : UniformSpace α] [Finite ι]
{F : ι → X → α} {S : Set X}, EquicontinuousOn F S ↔ ∀ (i : ι), ContinuousOn (F i) S |
LinearEquiv.coord | Mathlib.LinearAlgebra.Span.Basic | (R : Type u_1) →
(M : Type u_4) →
[inst : Ring R] →
[IsDomain R] →
[inst_2 : AddCommGroup M] →
[inst_3 : Module R M] → [Module.IsTorsionFree R M] → (x : M) → x ≠ 0 → ↥(R ∙ x) ≃ₗ[R] R |
Stream'.Seq.length.congr_simp | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (s s_1 : Stream'.Seq α) (e_s : s = s_1) (h : s.Terminates), s.length h = s_1.length ⋯ |
_private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.coeff_weierstrassPExceptSeries._simp_1_4 | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G) (n : ℕ), a ^ n = a ^ ↑n |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_369 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α) (h_3 : ¬[g a, g (g a)].Nodup) (w_1 : α)
(h_5 : 2 ≤ List.count w_1 [g a, g (g a)]),
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[List.idxOfNth w_1 [g a, g (g a)] {g a, g (g a)}.card] + 1 ≤
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length →
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[List.idxOfNth w_1 [g a, g (g a)] {g a, g (g a)}.card] <
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length |
FourierInvModule._sizeOf_inst | Mathlib.Analysis.Fourier.Notation | (R : Type u_5) →
(E : Type u_6) →
(F : outParam (Type u_7)) →
{inst : Add E} →
{inst_1 : Add F} →
{inst_2 : SMul R E} →
{inst_3 : SMul R F} → [SizeOf R] → [SizeOf E] → [SizeOf F] → SizeOf (FourierInvModule R E F) |
CochainComplex.HomComplex.Cocycle.equivHom_apply | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(F G : CochainComplex C ℤ) (φ : F ⟶ G),
(CochainComplex.HomComplex.Cocycle.equivHom F G) φ = CochainComplex.HomComplex.Cocycle.ofHom φ |
Lean.Parser.Term.doSeqItem | Lean.Parser.Do | Lean.Parser.Parser |
_private.Lean.PrivateName.0.Lean.privatePrefixAux._unsafe_rec | Lean.PrivateName | Lean.Name → Lean.Name |
AddOpposite.unop_sub | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : SubNegMonoid α] (x y : αᵃᵒᵖ),
AddOpposite.unop (x - y) = -AddOpposite.unop y + AddOpposite.unop x |
Std.ExtHashMap.get?.congr_simp | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
(m m_1 : Std.ExtHashMap α β), m = m_1 → ∀ (a a_1 : α), a = a_1 → m.get? a = m_1.get? a_1 |
CategoryTheory.functorialSurjectiveInjectiveFactorizationData._proof_6 | Mathlib.CategoryTheory.MorphismProperty.Concrete | ∀ (f : CategoryTheory.Arrow (Type u_1)),
CategoryTheory.MorphismProperty.surjective (Type u_1) ({ app := fun f x => ⟨f.hom x, ⋯⟩, naturality := ⋯ }.app f) |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.IsPath.neighborSet_toSubgraph_internal._proof_1_1 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {i : ℕ}, i ≠ 0 → i - 1 + 1 = i |
_private.Mathlib.Util.Notation3.0.Mathlib.Notation3.mkExprMatcher.match_1 | Mathlib.Util.Notation3 | (motive : Lean.LocalContext × Std.HashMap Lean.FVarId Lean.Name → Sort u_1) →
(__discr : Lean.LocalContext × Std.HashMap Lean.FVarId Lean.Name) →
((lctx : Lean.LocalContext) → (boundFVars : Std.HashMap Lean.FVarId Lean.Name) → motive (lctx, boundFVars)) →
motive __discr |
_private.Lean.Meta.Tactic.Grind.Arith.Simproc.0._regBuiltin.Lean.Meta.Grind.Arith.normNatAddInst.declare_33._@.Lean.Meta.Tactic.Grind.Arith.Simproc.114900174._hygCtx._hyg.16 | Lean.Meta.Tactic.Grind.Arith.Simproc | IO Unit |
LocalizedModule.instSemiring._proof_5 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : Algebra R A] {S : Submonoid R}
(a : LocalizedModule S A), a * 0 = 0 |
VectorPrebundle.continuousOn_coordChange | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} {E : B → Type u_4} [inst : NontriviallyNormedField R]
[inst_1 : (x : B) → AddCommMonoid (E x)] [inst_2 : (x : B) → Module R (E x)] [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace R F] [inst_5 : TopologicalSpace B] [inst_6 : (x : B) → TopologicalSpace (E x)]
(a : VectorPrebundle R F E) {e e' : Bundle.Pretrivialization F Bundle.TotalSpace.proj}
(he : e ∈ a.pretrivializationAtlas) (he' : e' ∈ a.pretrivializationAtlas),
ContinuousOn (a.coordChange he he') (e.baseSet ∩ e'.baseSet) |
Finset.univ_nontrivial_iff | Mathlib.Data.Finset.BooleanAlgebra | ∀ {α : Type u_1} [inst : Fintype α], Finset.univ.Nontrivial ↔ Nontrivial α |
tendstoLocallyUniformlyOn_iff_tendstoLocallyUniformly_comp_coe | Mathlib.Topology.UniformSpace.LocallyUniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [inst : TopologicalSpace α] [inst_1 : UniformSpace β] {F : ι → α → β}
{f : α → β} {s : Set α} {p : Filter ι},
TendstoLocallyUniformlyOn F f p s ↔ TendstoLocallyUniformly (fun i x => F i ↑x) (f ∘ Subtype.val) p |
CategoryTheory.Functor.IsCoverDense.Types.presheafHom_app | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {K : CategoryTheory.GrothendieckTopology D}
{G : CategoryTheory.Functor C D} {ℱ : CategoryTheory.Functor Dᵒᵖ (Type v)} {ℱ' : CategoryTheory.Sheaf K (Type v)}
[inst_2 : G.IsCoverDense K] [inst_3 : G.IsLocallyFull K] (α : G.op.comp ℱ ⟶ G.op.comp ℱ'.val) (X : Dᵒᵖ)
(a : ℱ.obj (Opposite.op (Opposite.unop X))),
(CategoryTheory.Functor.IsCoverDense.Types.presheafHom α).app X a =
CategoryTheory.Functor.IsCoverDense.Types.appHom α (Opposite.unop X) a |
_private.Mathlib.ModelTheory.Syntax.0.FirstOrder.Language.Term.varFinsetLeft.match_1.eq_2 | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {α : Type u_4} {β : Type u_3} (motive : L.Term (α ⊕ β) → Sort u_5) (_i : β)
(h_1 : (i : α) → motive (FirstOrder.Language.var (Sum.inl i)))
(h_2 : (_i : β) → motive (FirstOrder.Language.var (Sum.inr _i)))
(h_3 : (l : ℕ) → (_f : L.Functions l) → (ts : Fin l → L.Term (α ⊕ β)) → motive (FirstOrder.Language.func _f ts)),
(match FirstOrder.Language.var (Sum.inr _i) with
| FirstOrder.Language.var (Sum.inl i) => h_1 i
| FirstOrder.Language.var (Sum.inr _i) => h_2 _i
| FirstOrder.Language.func _f ts => h_3 l _f ts) =
h_2 _i |
CategoryTheory.MorphismProperty.pullback_snd_iff | Mathlib.CategoryTheory.MorphismProperty.Descent | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P Q : CategoryTheory.MorphismProperty C} {X Y Z : C}
{f : X ⟶ Z} {g : Y ⟶ Z} [P.IsStableUnderBaseChange] [P.DescendsAlong Q]
[inst_3 : CategoryTheory.Limits.HasPullback f g], Q g → (P (CategoryTheory.Limits.pullback.snd f g) ↔ P f) |
Polynomial.sylveserMap_comp_adjSylvester | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {m n : ℕ} {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (hf : f.natDegree ≤ m) (hg : g.natDegree ≤ n),
f.sylvesterMap g hf hg ∘ₗ f.adjSylvester g = f.resultant g m n • LinearMap.id |
Polynomial.mahlerMeasure_const | Mathlib.Analysis.Polynomial.MahlerMeasure | ∀ (z : ℂ), (Polynomial.C z).mahlerMeasure = ‖z‖ |
Std.TreeMap.getKey?_map | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp]
{f : α → β → γ} {k : α}, (Std.TreeMap.map f t).getKey? k = t.getKey? k |
CategoryTheory.FreeMonoidalCategory.HomEquiv.below.tensorHom_comp_tensorHom | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u}
{motive :
{X Y : CategoryTheory.FreeMonoidalCategory C} →
(a a_1 : X.Hom Y) → CategoryTheory.FreeMonoidalCategory.HomEquiv a a_1 → Prop}
{X₁ Y₁ Z₁ X₂ Y₂ Z₂ : CategoryTheory.FreeMonoidalCategory C} (f₁ : X₁.Hom Y₁) (f₂ : X₂.Hom Y₂) (g₁ : Y₁.Hom Z₁)
(g₂ : Y₂.Hom Z₂), CategoryTheory.FreeMonoidalCategory.HomEquiv.below ⋯ |
_private.Lean.Compiler.LCNF.Simp.InlineProj.0.Lean.Compiler.LCNF.Simp.inlineProjInst?.visit.match_3 | Lean.Compiler.LCNF.Simp.InlineProj | (motive : List ℕ → Sort u_1) →
(projs : List ℕ) → ((i : ℕ) → (projs : List ℕ) → motive (i :: projs)) → ((x : List ℕ) → motive x) → motive projs |
_private.Mathlib.Data.Vector3.0.Fin2.insertPerm.match_1.eq_3 | Mathlib.Data.Vector3 | ∀ (motive : (x : ℕ) → Fin2 x → Fin2 x → Sort u_1) (a : ℕ) (a_1 : Fin2 a.succ)
(h_1 : (n : ℕ) → motive (n + 1) Fin2.fz Fin2.fz) (h_2 : (n : ℕ) → (j : Fin2 n) → motive (n + 1) Fin2.fz j.fs)
(h_3 : (a : ℕ) → (a_2 : Fin2 a.succ) → motive (a.succ + 1) a_2.fs Fin2.fz)
(h_4 : (a : ℕ) → (i : Fin2 a.succ) → (j : Fin2 (a + 1)) → motive (a.succ + 1) i.fs j.fs),
(match a.succ + 1, a_1.fs, Fin2.fz with
| .(n + 1), Fin2.fz, Fin2.fz => h_1 n
| .(n + 1), Fin2.fz, j.fs => h_2 n j
| .(a.succ + 1), a_2.fs, Fin2.fz => h_3 a a_2
| .(a.succ + 1), i.fs, j.fs => h_4 a i j) =
h_3 a a_1 |
Lean.Compiler.LCNF.SpecEntry.mk.noConfusion | Lean.Compiler.LCNF.SpecInfo | {P : Sort u} →
{declName : Lean.Name} →
{paramsInfo : Array Lean.Compiler.LCNF.SpecParamInfo} →
{alreadySpecialized : Bool} →
{declName' : Lean.Name} →
{paramsInfo' : Array Lean.Compiler.LCNF.SpecParamInfo} →
{alreadySpecialized' : Bool} →
{ declName := declName, paramsInfo := paramsInfo, alreadySpecialized := alreadySpecialized } =
{ declName := declName', paramsInfo := paramsInfo', alreadySpecialized := alreadySpecialized' } →
(declName = declName' → paramsInfo = paramsInfo' → alreadySpecialized = alreadySpecialized' → P) → P |
Batteries.RBNode.lowerBound? | Batteries.Data.RBMap.Basic | {α : Type u_1} → (α → Ordering) → Batteries.RBNode α → optParam (Option α) none → Option α |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.