name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
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₂] | true |
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) | true |
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 | true |
_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 () | true |
_private.Lean.Compiler.ExportAttr.0.Lean.isValidCppName | Lean.Compiler.ExportAttr | Lean.Name → Bool | true |
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.pullba... | true |
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 (Categor... | true |
_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 | false |
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 | true |
Denumerable.nat | Mathlib.Logic.Denumerable | Denumerable ℕ | true |
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 | true |
_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 | false |
_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 | true |
_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 | 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).obj → F.obj (FintypeCat.toLightProfinite.op.obj (Opposite.op (FintypeCat.of PUn... | false |
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 | false |
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.invtSubmodu... | true |
_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 | false |
MeasureTheory.integrableOn_indicator_iff | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {ε' : Type u_4} {mα : MeasurableSpace α} {s t : Set α} {μ : MeasureTheory.Measure α}
[inst : TopologicalSpace ε'] [inst_1 : ESeminormedAddMonoid ε'] {f : α → ε'},
MeasurableSet s → (MeasureTheory.IntegrableOn (s.indicator f) t μ ↔ MeasureTheory.IntegrableOn f (s ∩ t) μ) | 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 | true |
Lean.mkIntDvd | Lean.Expr | Lean.Expr → Lean.Expr → Lean.Expr | true |
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... | true |
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) | true |
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 | true |
ModuleCat.hom_surjective | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u} [inst : Ring R] {M N : ModuleCat R}, Function.Surjective ModuleCat.Hom.hom | true |
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' | true |
Lean.Core.SavedState.messages._inherited_default | Lean.CoreM | Lean.MessageLog | false |
Algebra.ctorIdx | Mathlib.Algebra.Algebra.Defs | {R : Type u} → {A : Type v} → {inst : CommSemiring R} → {inst_1 : Semiring A} → Algebra R A → ℕ | false |
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 | false |
Locale.localePointOfSpacePoint._proof_3 | Mathlib.Topology.Order.Category.FrameAdjunction | ∀ (X : Type u_1) [inst : TopologicalSpace X] (x : X), (x ∈ ⊤) = (x ∈ ⊤) | false |
IsDivSequence | Mathlib.NumberTheory.EllipticDivisibilitySequence | {R : Type u} → [CommRing R] → (ℤ → R) → Prop | true |
_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 | false |
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 | true |
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) | true |
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... | true |
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 | false |
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 | true |
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.τ₂ | false |
Equiv.ofIff._proof_2 | Mathlib.Logic.Equiv.Defs | ∀ {P Q : Prop} (h : P ↔ Q) (x : P), ⋯ = ⋯ | false |
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... | true |
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 | false |
_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 | 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) | true |
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ᵒᵖ | true |
Lean.Parser.Command.catBehaviorBoth | Lean.Parser.Syntax | Lean.Parser.Parser | true |
MeasureTheory.Measure.haveLebesgueDecomposition_add | Mathlib.MeasureTheory.Measure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} (μ ν : MeasureTheory.Measure α) [μ.HaveLebesgueDecomposition ν],
μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν) | true |
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' | false |
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 ... | true |
Std.CancellationToken.State.mk | Std.Sync.CancellationToken | Option Std.CancellationReason → Std.Queue Std.CancellationToken.Consumer → Std.CancellationToken.State | true |
_private.Mathlib.Data.Nat.MaxPowDiv.0.Nat.pow_dvd_iff_le_of_spec | Mathlib.Data.Nat.MaxPowDiv | ∀ {p k n a b : ℕ}, 1 < p → n ≠ 0 → p ^ a * b = n → ¬p ∣ b → (p ^ k ∣ n ↔ k ≤ a) | true |
Set.exists_ne_of_one_lt_ncard | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α}, 1 < s.ncard → ∀ (a : α), ∃ b ∈ s, b ≠ a | true |
Preorder.toGradeBoundedOrder._proof_1 | Mathlib.Order.Grade | ∀ {α : Type u_1} [inst : Preorder α] (x x_1 : α), x ⋖ x_1 → x ⋖ x_1 | false |
Lean.Elab.Tactic.Do.addMData | Lean.Elab.Tactic.Do.LetElim | Lean.MData → Lean.Expr → Lean.Expr | true |
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 | true |
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 | false |
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 | false |
_private.Lean.DocString.Formatter.0.Lean.Doc.Parser.versoSyntaxToString | Lean.DocString.Formatter | Lean.Syntax → String | true |
_private.Mathlib.FieldTheory.AbelRuffini.0.solvableByRad.eq_1 | Mathlib.FieldTheory.AbelRuffini | ∀ (F : Type u_1) (E : Type u_2) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E],
solvableByRad F E = sInf {s | ∀ (x : E) (n : ℕ), n ≠ 0 → x ^ n ∈ s → x ∈ s} | true |
Lean.Meta.DefEqCacheKind.transient | Lean.Meta.ExprDefEq | Lean.Meta.DefEqCacheKind | true |
UpperSet.coe_iSup._simp_2 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} {ι : Sort u_4} [inst : LE α] (f : ι → UpperSet α), ⋂ i, ↑(f i) = ↑(⨆ i, f i) | false |
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 | true |
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) | true |
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 | false |
Hamming.instModule._proof_2 | Mathlib.InformationTheory.Hamming | ∀ {ι : Type u_1} (α : Type u_3) [inst : Semiring α] (β : ι → Type u_2) [inst_1 : (i : ι) → AddCommMonoid (β i)]
[inst_2 : (i : ι) → Module α (β i)] (b : Hamming β), 1 • b = b | false |
_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 | false |
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] →
... | true |
ContravariantClass | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | (M : Type u_1) → (N : Type u_2) → (M → N → N) → (N → N → Prop) → Prop | true |
_private.Mathlib.Order.SuccPred.Archimedean.0.Set.OrdConnected.isSuccArchimedean._proof_2 | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] [IsSuccArchimedean α] (s : Set α)
[inst_3 : s.OrdConnected], IsSuccArchimedean ↑s | false |
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) | true |
Polynomial.instCommRingUniversalFactorizationRing._proof_31 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} (m k : ℕ) (hn : n = m + k) (p : Polynomial.MonicDegreeEq R n),
autoParam
(∀ (n_1 : ℕ) (x : Polynomial.UniversalFactorizationRing m k hn p),
Polynomial.instCommRingUniversalFactorizationRing._aux_28 m k hn p (n_1 + 1) x =
Polynomial.instCommRingUniversalFa... | false |
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₁ : CategoryThe... | false |
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 | true |
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 | true |
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 ⋯ | true |
_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 | false |
_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 (... | false |
Submodule.IsAssociatedPrime.recOn | Mathlib.RingTheory.Ideal.AssociatedPrime.Basic | {R : Type u_1} →
{M : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
{N : Submodule R M} →
{I : Ideal R} →
{motive : N.IsAssociatedPrime I → Sort u} →
(t : N.IsAssociatedPrime I) →
((toI... | false |
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) | false |
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 φ | true |
Lean.Parser.Term.doSeqItem | Lean.Parser.Do | Lean.Parser.Parser | true |
_private.Lean.PrivateName.0.Lean.privatePrefixAux._unsafe_rec | Lean.PrivateName | Lean.Name → Lean.Name | false |
AddOpposite.unop_sub | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : SubNegMonoid α] (x y : αᵃᵒᵖ),
AddOpposite.unop (x - y) = -AddOpposite.unop y + AddOpposite.unop x | true |
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 | true |
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) | false |
_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 | false |
_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 | false |
_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 | false |
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 | false |
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 ... | true |
Finset.univ_nontrivial_iff | Mathlib.Data.Finset.BooleanAlgebra | ∀ {α : Type u_1} [inst : Fintype α], Finset.univ.Nontrivial ↔ Nontrivial α | true |
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 | true |
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] [i... | true |
_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 (Fi... | true |
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) | true |
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 | true |
Polynomial.mahlerMeasure_const | Mathlib.Analysis.Polynomial.MahlerMeasure | ∀ (z : ℂ), (Polynomial.C z).mahlerMeasure = ‖z‖ | true |
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 | true |
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.FreeMono... | true |
_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 | false |
_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 +... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.