name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Polynomial.map_ne_zero | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} {S : Type v} [inst : Ring R] [IsSimpleRing R] [inst_2 : Semiring S] [Nontrivial S] {p : Polynomial R}
{f : R →+* S}, p ≠ 0 → Polynomial.map f p ≠ 0 | true |
CategoryTheory.CostructuredArrow.mapIso_functor_obj_hom | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{T T' : D} {S : CategoryTheory.Functor C D} (i : T ≅ T')
(X : CategoryTheory.Comma S (CategoryTheory.Functor.fromPUnit T)),
((CategoryTheory.CostructuredArrow.mapIso i).functor.obj X).hom = CategoryTheory.CategoryStruct.comp X.hom i.hom | true |
Lean.Widget.instFromJsonRpcEncodablePacket._@.Lean.Widget.InteractiveGoal.2427803292._hygCtx._hyg.18 | Lean.Widget.InteractiveGoal | Lean.FromJson Lean.Widget.RpcEncodablePacket✝ | false |
CategoryTheory.Bicategory.associator_naturality_left_assoc | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : B} {f f' : a ⟶ b} (η : f ⟶ f') (g : b ⟶ c) (h : c ⟶ d)
{Z : a ⟶ d} (h_1 : CategoryTheory.CategoryStruct.comp f' (CategoryTheory.CategoryStruct.comp g h) ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (CategoryTheory.Bicategory.whiskerRight η g) h)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator f' g h).hom h_1) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator f g h).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight η (CategoryTheory.CategoryStruct.comp g h)) h_1) | true |
CategoryTheory.ShortComplex.HomotopyEquiv.homotopyInvHomId | Mathlib.Algebra.Homology.ShortComplex.Preadditive | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
(self : S₁.HomotopyEquiv S₂) →
CategoryTheory.ShortComplex.Homotopy (CategoryTheory.CategoryStruct.comp self.inv self.hom)
(CategoryTheory.CategoryStruct.id S₂) | true |
groupHomology.inhomogeneousChains.d_single | Mathlib.RepresentationTheory.Homological.GroupHomology.Basic | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A : Rep.{u, u, u} k G} (n : ℕ) (g : Fin (n + 1) → G) (a : ↑A),
((CategoryTheory.ConcreteCategory.hom (groupHomology.inhomogeneousChains.d A n)) fun₀ | g => a) =
(fun₀ | fun i => g i.succ => (A.ρ (g 0)⁻¹) a) +
∑ j, (-1) ^ (↑j + 1) • fun₀ | j.contractNth (fun x1 x2 => x1 * x2) g => a | true |
Lean.Grind.IntModule.OfNatModule.instLEQOfOrderedAdd | Init.Grind.Module.Envelope | {α : Type u} →
[inst : Lean.Grind.NatModule α] →
[inst_1 : LE α] →
[inst_2 : Std.IsPreorder α] → [Lean.Grind.OrderedAdd α] → LE (Lean.Grind.IntModule.OfNatModule.Q α) | true |
_private.Mathlib.Order.Fin.Tuple.0.Fin.preimage_insertNth_Icc_of_notMem._simp_1_2 | Mathlib.Order.Fin.Tuple | ∀ {n : ℕ} {α : Fin (n + 1) → Type u_1} [inst : (i : Fin (n + 1)) → Preorder (α i)] {i : Fin (n + 1)} {x : α i}
{p : (j : Fin n) → α (i.succAbove j)} {q₁ q₂ : (j : Fin (n + 1)) → α j},
(i.insertNth x p ∈ Set.Icc q₁ q₂) =
(x ∈ Set.Icc (q₁ i) (q₂ i) ∧ p ∈ Set.Icc (fun j => q₁ (i.succAbove j)) fun j => q₂ (i.succAbove j)) | false |
Ring.DirectLimit.ringEquiv_of | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] (G : ι → Type u_2) [inst_1 : (i : ι) → CommRing (G i)]
(f' : (i j : ι) → i ≤ j → G i →+* G j) [inst_2 : DirectedSystem G fun i j h => ⇑(f' i j h)]
[inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι] {i : ι} {g : G i},
(Ring.DirectLimit.ringEquiv G f') ((Ring.DirectLimit.of G (fun x1 x2 x3 => ⇑(f' x1 x2 x3)) i) g) = ⟦⟨i, g⟩⟧ | true |
Int.bmod_eq_of_le | Init.Data.Int.DivMod.Lemmas | ∀ {n : ℤ} {m : ℕ}, -(↑m / 2) ≤ n → n < (↑m + 1) / 2 → n.bmod m = n | true |
Lean.MessageLog.hasErrors | Lean.Message | Lean.MessageLog → Bool | true |
Algebra.TensorProduct.piRight._proof_2 | Mathlib.RingTheory.TensorProduct.Pi | ∀ (R : Type u_1) (S : Type u_5) (A : Type u_2) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
[inst_3 : Semiring A] [inst_4 : Algebra R A] [inst_5 : Algebra S A] [inst_6 : IsScalarTower R S A] {ι : Type u_3}
(B : ι → Type u_4) [inst_7 : (i : ι) → Semiring (B i)] [inst_8 : (i : ι) → Algebra R (B i)] [inst_9 : Fintype ι]
[inst_10 : DecidableEq ι] (x y : TensorProduct R A ((i : ι) → B i)),
(TensorProduct.piRight R S A B) (x * y) = (TensorProduct.piRight R S A B) x * (TensorProduct.piRight R S A B) y | false |
CommRingCat.monoidAlgebraAdj._proof_2 | Mathlib.Algebra.Category.Ring.Adjunctions | ∀ (R : CommRingCat) ⦃X Y : CommMonCat⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id CommMonCat).map f)
(CommMonCat.ofHom (MonoidAlgebra.of ↑R ↑Y)) =
CategoryTheory.CategoryStruct.comp (CommMonCat.ofHom (MonoidAlgebra.of ↑R ↑X))
((R.monoidAlgebra.comp ((CategoryTheory.Under.forget R).comp (CategoryTheory.forget₂ CommRingCat CommMonCat))).map
f) | false |
AddSubgroup.properlyDiscontinuousVAdd_of_tendsto_cofinite | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [IsTopologicalAddGroup G] (S : AddSubgroup G),
Filter.Tendsto (⇑S.subtype) Filter.cofinite (Filter.cocompact G) → ProperlyDiscontinuousVAdd (↥S) G | true |
CategoryTheory.MorphismProperty.of_postcomp | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C)
{W' : CategoryTheory.MorphismProperty C} [W.HasOfPostcompProperty W'] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
W' g → W (CategoryTheory.CategoryStruct.comp f g) → W f | true |
_private.Mathlib.Algebra.Order.Group.Pointwise.Interval.0.Set.inv_Ioc._simp_1_2 | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ico a b = Set.Ici a ∩ Set.Iio b | false |
Lean.Server.Test.Runner.RunnerState.versionNo | Lean.Server.Test.Runner | Lean.Server.Test.Runner.RunnerState → ℕ | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.isEmpty_toList._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
Std.DTreeMap.Internal.Impl.size_inter!_le_size_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
m₁.WF → m₂.WF → (m₁.inter! m₂).size ≤ m₁.size | true |
CategoryTheory.Grp.rightUnitor_inv_hom | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (G : CategoryTheory.Grp C),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor G).inv.hom.hom =
(CategoryTheory.MonoidalCategoryStruct.rightUnitor G.X).inv | true |
BddOrd.hom_comp | Mathlib.Order.Category.BddOrd | ∀ {X Y Z : BddOrd} (f : X ⟶ Y) (g : Y ⟶ Z),
BddOrd.Hom.hom (CategoryTheory.CategoryStruct.comp f g) = (BddOrd.Hom.hom g).comp (BddOrd.Hom.hom f) | true |
Lean.Compiler.LCNF.Simp.FunDeclInfoMap.addMustInline | Lean.Compiler.LCNF.Simp.FunDeclInfo | Lean.Compiler.LCNF.Simp.FunDeclInfoMap → Lean.FVarId → Lean.Compiler.LCNF.Simp.FunDeclInfoMap | true |
Relation.symmGen_swap_apply | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {a b : α} (r : α → α → Prop), Relation.SymmGen (Function.swap r) a b ↔ Relation.SymmGen r a b | true |
Fin.sum_univ_add | Mathlib.Algebra.BigOperators.Fin | ∀ {M : Type u_2} [inst : AddCommMonoid M] {a b : ℕ} (f : Fin (a + b) → M),
∑ i, f i = ∑ i, f (Fin.castAdd b i) + ∑ i, f (Fin.natAdd a i) | true |
LLVM.pointerType | Lean.Compiler.IR.LLVMBindings | {ctx : LLVM.Context} → LLVM.LLVMType ctx → BaseIO (LLVM.LLVMType ctx) | true |
NormedCommGroup.ofMulDist'.eq_1 | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_5} [inst : Norm E] [inst_1 : CommGroup E] [inst_2 : MetricSpace E] (h₁ : ∀ (x : E), ‖x‖ = dist 1 x)
(h₂ : ∀ (x y z : E), dist (z * x) (z * y) ≤ dist x y),
NormedCommGroup.ofMulDist' h₁ h₂ =
{ toNorm := (NormedGroup.ofMulDist' h₁ h₂).toNorm, toGroup := (NormedGroup.ofMulDist' h₁ h₂).toGroup, mul_comm := ⋯,
toMetricSpace := (NormedGroup.ofMulDist' h₁ h₂).toMetricSpace, dist_eq := ⋯ } | true |
LinearMap.lsmul_injective | Mathlib.LinearAlgebra.BilinearMap | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [IsDomain R] [inst_2 : AddCommGroup M] [inst_3 : Module R M]
[Module.IsTorsionFree R M] {x : R}, x ≠ 0 → Function.Injective ⇑((LinearMap.lsmul R M) x) | true |
_private.Mathlib.NumberTheory.LSeries.HurwitzZetaOdd.0.HurwitzZeta.hasSum_int_sinKernel._simp_1_1 | Mathlib.NumberTheory.LSeries.HurwitzZetaOdd | ∀ {α : Type u_1} [inst : SubtractionMonoid α] {a : α}, (-a = 0) = (a = 0) | false |
MeasureTheory.setLIntegral_nnnorm_condExpL2_indicator_le | Mathlib.MeasureTheory.Function.ConditionalExpectation.CondexpL2 | ∀ {α : Type u_1} {E' : Type u_3} {𝕜 : Type u_7} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E']
[inst_2 : InnerProductSpace 𝕜 E'] [inst_3 : CompleteSpace E'] [NormedSpace ℝ E'] {m m0 : MeasurableSpace α}
{μ : MeasureTheory.Measure α} {s : Set α} (hm : m ≤ m0) (hs : MeasurableSet s) (hμs : μ s ≠ ⊤) (x : E') {t : Set α},
MeasurableSet t →
μ t ≠ ⊤ →
∫⁻ (a : α) in t, ↑‖↑↑↑((MeasureTheory.condExpL2 E' 𝕜 hm) (MeasureTheory.indicatorConstLp 2 hs hμs x)) a‖₊ ∂μ ≤
μ (s ∩ t) * ↑‖x‖₊ | true |
DirectLimit.map₂_def₂ | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_1} [inst : Preorder ι] {F₁ : ι → Type u_2} {F₂ : ι → Type u_3} {F : ι → Type u_4}
{T₁ : ⦃i j : ι⦄ → i ≤ j → Sort u_6} (f₁ : (i j : ι) → (h : i ≤ j) → T₁ h)
[inst_1 : ⦃i j : ι⦄ → (h : i ≤ j) → FunLike (T₁ h) (F₁ i) (F₁ j)]
[inst_2 : DirectedSystem F₁ fun x1 x2 x3 => ⇑(f₁ x1 x2 x3)] {T₂ : ⦃i j : ι⦄ → i ≤ j → Sort u_7}
(f₂ : (i j : ι) → (h : i ≤ j) → T₂ h) [inst_3 : ⦃i j : ι⦄ → (h : i ≤ j) → FunLike (T₂ h) (F₂ i) (F₂ j)]
[inst_4 : DirectedSystem F₂ fun x1 x2 x3 => ⇑(f₂ x1 x2 x3)] {T : ⦃i j : ι⦄ → i ≤ j → Sort u_8}
(f : (i j : ι) → (h : i ≤ j) → T h) [inst_5 : ⦃i j : ι⦄ → (h : i ≤ j) → FunLike (T h) (F i) (F j)]
[inst_6 : DirectedSystem F fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_7 : IsDirectedOrder ι]
(ih : (i : ι) → F₁ i → F₂ i → F i)
(compat : ∀ (i j : ι) (h : i ≤ j) (x : F₁ i) (y : F₂ i), (f i j h) (ih i x y) = ih j ((f₁ i j h) x) ((f₂ i j h) y))
(x : (i : ι) × F₁ i) (y : (i : ι) × F₂ i) (i : ι) (hxi : x.fst ≤ i) (hyi : y.fst ≤ i),
DirectLimit.map₂ f₁ f₂ f ih compat ⟦x⟧ ⟦y⟧ = ⟦⟨i, ih i ((f₁ x.fst i hxi) x.snd) ((f₂ y.fst i hyi) y.snd)⟩⟧ | true |
Ideal.quotientToQuotientRangePowQuotSucc._proof_4 | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {R : Type u_2} [inst : CommRing R] {S : Type u_1} [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R)
(P : Ideal S) [hfp : NeZero (p.ramificationIdx P)] {i : ℕ} {a : S} (a_mem : a ∈ P ^ i) (x : R ⧸ p) (y : S ⧸ P),
p.quotientToQuotientRangePowQuotSuccAux P a_mem (x • y) =
(RingHom.id (R ⧸ p)) x • p.quotientToQuotientRangePowQuotSuccAux P a_mem y | false |
Lean.JsonRpc.instInhabitedMessage | Lean.Data.JsonRpc | Inhabited Lean.JsonRpc.Message | true |
_private.Lean.Server.FileWorker.SemanticHighlighting.0.Lean.Server.FileWorker.computeAbsoluteLspSemanticTokens.match_3 | Lean.Server.FileWorker.SemanticHighlighting | (motive : String.Pos.Raw × String.Pos.Raw → Sort u_1) →
(x : String.Pos.Raw × String.Pos.Raw) → ((pos tailPos : String.Pos.Raw) → motive (pos, tailPos)) → motive x | false |
Std.Iter.filterM | Init.Data.Iterators.Combinators.FilterMap | {α β : Type w} →
[Std.Iterator α Id β] →
{m : Type w → Type w'} →
[inst : Monad m] → [inst_1 : MonadAttach m] → (f : β → m (ULift.{w, 0} Bool)) → Std.Iter β → Std.IterM m β | true |
_private.Batteries.Tactic.HelpCmd.0.Batteries.Tactic.elabHelpAttr.match_1 | Batteries.Tactic.HelpCmd | (motive : Lean.Name × Lean.AttributeImpl → Sort u_1) →
(x : Lean.Name × Lean.AttributeImpl) →
((name : Lean.Name) → (decl : Lean.AttributeImpl) → motive (name, decl)) → motive x | false |
skyscraperPresheafCoconeIsColimitOfNotSpecializes._proof_4 | Mathlib.Topology.Sheaves.Skyscraper | ∀ {X : TopCat} (p₀ : ↑X) [inst : (U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] (A : C) [inst_2 : CategoryTheory.Limits.HasTerminal C] {y : ↑X}
(h : ¬p₀ ⤳ y)
(c : CategoryTheory.Limits.Cocone ((TopologicalSpace.OpenNhds.inclusion y).op.comp (skyscraperPresheaf p₀ A)))
(U : (TopologicalSpace.OpenNhds y)ᵒᵖ),
CategoryTheory.CategoryStruct.comp ((skyscraperPresheafCocone p₀ A y).ι.app U)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (c.ι.app (Opposite.op ⋯.choose))) =
c.ι.app U | false |
SimpleGraph.TripartiteFromTriangles.Graph.not_in₀₀ | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {t : Finset (α × β × γ)} {a a' : α},
¬(SimpleGraph.TripartiteFromTriangles.graph t).Adj (Sum3.in₀ a) (Sum3.in₀ a') | true |
Ideal.isMaximal_iff_isPrime | Mathlib.RingTheory.KrullDimension.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] [Ring.KrullDimLE 0 R] {I : Ideal R}, I.IsMaximal ↔ I.IsPrime | true |
Std.ExtHashSet.get_insert | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{k a : α} {h₁ : a ∈ m.insert k}, (m.insert k).get a h₁ = if h₂ : (k == a) = true ∧ k ∉ m then k else m.get a ⋯ | true |
Mathlib.Tactic.AtomM.Recurse.Config.casesOn | Mathlib.Util.AtomM.Recurse | {motive : Mathlib.Tactic.AtomM.Recurse.Config → Sort u} →
(t : Mathlib.Tactic.AtomM.Recurse.Config) →
((red : Lean.Meta.TransparencyMode) →
(zetaDelta contextual : Bool) → motive { red := red, zetaDelta := zetaDelta, contextual := contextual }) →
motive t | false |
Lean.Elab.Tactic.Do.instOrdUses.ord | Lean.Elab.Tactic.Do.LetElim | Lean.Elab.Tactic.Do.Uses → Lean.Elab.Tactic.Do.Uses → Ordering | true |
CategoryTheory.conjugateIsoEquiv_symm_apply_inv | Mathlib.CategoryTheory.Adjunction.Mates | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{L₁ L₂ : CategoryTheory.Functor C D} {R₁ R₂ : CategoryTheory.Functor D C} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂)
(β : R₁ ≅ R₂),
((CategoryTheory.conjugateIsoEquiv adj₁ adj₂).symm β).inv = (CategoryTheory.conjugateEquiv adj₂ adj₁).symm β.inv | true |
_private.Std.Data.HashMap.IteratorLemmas.0.Std.HashMap.toArray_iter._simp_1_1 | Std.Data.HashMap.IteratorLemmas | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] {it : Std.Iter β},
it.toArray = it.toList.toArray | false |
Array.foldl_reverse | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {f : β → α → β} {b : β},
Array.foldl f b xs.reverse = Array.foldr (fun x y => f y x) b xs | true |
Circle.coeHom | Mathlib.Analysis.Complex.Circle | Circle →* ℂ | true |
CategoryTheory.Functor.mapCoconeWhisker.eq_1 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} D] (H : CategoryTheory.Functor C D) {F : CategoryTheory.Functor J C}
{E : CategoryTheory.Functor K J} {c : CategoryTheory.Limits.Cocone F},
H.mapCoconeWhisker =
CategoryTheory.Limits.Cocone.ext_inv
(CategoryTheory.Iso.refl (H.mapCocone (CategoryTheory.Limits.Cocone.whisker E c)).pt) ⋯ | true |
PseudoEMetricSpace.noConfusion | Mathlib.Topology.EMetricSpace.Defs | {P : Sort u_1} →
{α : Type u} →
{t : PseudoEMetricSpace α} →
{α' : Type u} → {t' : PseudoEMetricSpace α'} → α = α' → t ≍ t' → PseudoEMetricSpace.noConfusionType P t t' | false |
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.Context.parentIsApp._default | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Bool | false |
SModEq.of_toAddSubgroup_le | Mathlib.LinearAlgebra.SModEq.Basic | ∀ {R : Type u_1} [inst : Ring R] {S : Type u_2} [inst_1 : Ring S] {M : Type u_4} [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : Module S M] {U : Submodule R M} {V : Submodule S M},
U.toAddSubgroup ≤ V.toAddSubgroup → ∀ {x y : M}, x ≡ y [SMOD U] → x ≡ y [SMOD V] | true |
AlgebraicGeometry.PresheafedSpace.isoOfComponents | Mathlib.Geometry.RingedSpace.PresheafedSpace | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X Y : AlgebraicGeometry.PresheafedSpace C} →
(H : ↑X ≅ ↑Y) → ((TopCat.Presheaf.pushforward C H.hom).obj X.presheaf ≅ Y.presheaf) → (X ≅ Y) | true |
Mathlib.Tactic.LinearCombination.Expanded._sizeOf_1 | Mathlib.Tactic.LinearCombination | Mathlib.Tactic.LinearCombination.Expanded → ℕ | false |
Turing.Tape.nth.eq_2 | Mathlib.Computability.TuringMachine.Tape | ∀ {Γ : Type u_1} [inst : Inhabited Γ] (T : Turing.Tape Γ) (n : ℕ), T.nth (Int.ofNat n.succ) = T.right.nth n | true |
_private.Mathlib.Tactic.Push.Attr.0.Mathlib.Tactic.Push.instBEqHead.beq._sparseCasesOn_1 | Mathlib.Tactic.Push.Attr | {motive : Mathlib.Tactic.Push.Head → Sort u} →
(t : Mathlib.Tactic.Push.Head) →
((c : Lean.Name) → motive (Mathlib.Tactic.Push.Head.const c)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.GrothendieckTopology.pseudofunctorOver_mapComp_hom_toNatTrans_app_hom_app | Mathlib.CategoryTheory.Sites.PseudofunctorSheafOver | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) (A : Type u')
[inst_1 : CategoryTheory.Category.{v', u'} A] {a b c : CategoryTheory.LocallyDiscrete Cᵒᵖ} (x : a ⟶ b) (x_1 : b ⟶ c)
(X : CategoryTheory.Sheaf (J.over (Opposite.unop a.as)) A) (X_1 : (CategoryTheory.Over (Opposite.unop c.as))ᵒᵖ),
(((J.pseudofunctorOver A).mapComp x x_1).hom.toNatTrans.app X).hom.app X_1 =
X.obj.map ((CategoryTheory.Over.mapComp x_1.as.unop x.as.unop).inv.app (Opposite.unop X_1)).op | true |
Lean.Meta.isDefEqOffset | Lean.Meta.Offset | Lean.Expr → Lean.Expr → Lean.MetaM Lean.LBool | true |
_private.Lean.Meta.Tactic.Grind.ProveEq.0.Lean.Meta.Grind.ensureInternalized | Lean.Meta.Tactic.Grind.ProveEq | Lean.Expr → Lean.Meta.Grind.GoalM Lean.Expr | true |
SimpleGraph.support_deleteIncidenceSet_subset | Mathlib.Combinatorics.SimpleGraph.DeleteEdges | ∀ {V : Type u_1} (G : SimpleGraph V) (x : V), (G.deleteIncidenceSet x).support ⊆ G.support \ {x} | true |
RootPairing.toInvariantForm_form | Mathlib.LinearAlgebra.RootSystem.Finite.Nondegenerate | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Fintype ι] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : CommRing R] [inst_4 : Module R M] [inst_5 : Module R N] (P : RootPairing ι R M N)
[inst_6 : P.IsAnisotropic], P.toInvariantForm.form = P.RootForm | true |
ULiftable.ctorIdx | Mathlib.Control.ULiftable | {f : outParam (Type u₀ → Type u₁)} → {g : Type v₀ → Type v₁} → ULiftable f g → ℕ | false |
Lex.instDistribSMul' | Mathlib.Algebra.Order.GroupWithZero.Action.Synonym | {G₀ : Type u_1} → {M₀ : Type u_2} → [inst : AddZeroClass M₀] → [DistribSMul G₀ M₀] → DistribSMul G₀ (Lex M₀) | true |
SeparationQuotient.instCommRing._proof_18 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : CommRing R] (n : ℤ), SeparationQuotient.mk ↑n = ↑n | false |
_private.Mathlib.Data.Set.Lattice.0.exists_sUnion._simp_1_2 | Mathlib.Data.Set.Lattice | ∀ {ι : Sort u_4} {p : ι → Prop}, (∃ i, p i) = ⨆ i, p i | false |
CategoryTheory.Limits.limitConstTerminal._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Terminal | ∀ {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.HasTerminal C],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.terminal.from (CategoryTheory.Limits.limit ((CategoryTheory.Functor.const J).obj (⊤_ C))))
(CategoryTheory.Limits.limit.lift ((CategoryTheory.Functor.const J).obj (⊤_ C))
{ pt := ⊤_ C,
π :=
{ app := fun x => CategoryTheory.Limits.terminal.from (((CategoryTheory.Functor.const J).obj (⊤_ C)).obj x),
naturality := ⋯ } }) =
CategoryTheory.CategoryStruct.id (CategoryTheory.Limits.limit ((CategoryTheory.Functor.const J).obj (⊤_ C))) | false |
Convex.isPathConnected | Mathlib.Analysis.Convex.PathConnected | ∀ {E : Type u_1} [inst : AddCommGroup E] [inst_1 : Module ℝ E] [inst_2 : TopologicalSpace E] [ContinuousAdd E]
[ContinuousSMul ℝ E] {s : Set E}, Convex ℝ s → s.Nonempty → IsPathConnected s | true |
Vector.mem_insertIdx | Init.Data.Vector.InsertIdx | ∀ {α : Type u} {a : α} {n i : ℕ} {b : α} {xs : Vector α n} {h : i ≤ n}, a ∈ xs.insertIdx i b h ↔ a = b ∨ a ∈ xs | true |
FractionalIdeal.inv_le_inv_iff._simp_1 | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {A : Type u_2} {K : Type u_3} [inst : CommRing A] [inst_1 : Field K] [inst_2 : IsDedekindDomain A]
[inst_3 : Algebra A K] [inst_4 : IsFractionRing A K] {I J : FractionalIdeal (nonZeroDivisors A) K},
I ≠ 0 → J ≠ 0 → (I⁻¹ ≤ J⁻¹) = (J ≤ I) | false |
Std.ExtDHashMap.Const.size_alter_eq_sub_one | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {f : Option β → Option β},
k ∈ m → (f (Std.ExtDHashMap.Const.get? m k)).isNone = true → (Std.ExtDHashMap.Const.alter m k f).size = m.size - 1 | true |
IsMIntegralCurveAt.comp_mul_ne_zero | Mathlib.Geometry.Manifold.IntegralCurve.Transform | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_2} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M] {γ : ℝ → M}
{v : (x : M) → TangentSpace I x} {t₀ : ℝ},
IsMIntegralCurveAt γ v t₀ → ∀ {a : ℝ}, a ≠ 0 → IsMIntegralCurveAt (γ ∘ fun x => x * a) (a • v) (t₀ / a) | true |
Lean.Widget.RpcEncodablePacket.mk._flat_ctor._@.Lean.Widget.UserWidget.3433604829._hygCtx._hyg.1 | Lean.Widget.UserWidget | Lean.Json → Lean.Json → Lean.Json → Option Lean.Json → Option Lean.Json → Lean.Widget.RpcEncodablePacket✝ | false |
IsGaloisGroup.mulEquivCongr | Mathlib.FieldTheory.Galois.IsGaloisGroup | (G : Type u_1) →
(H : Type u_2) →
(K : Type u_3) →
(L : Type u_4) →
[inst : Group G] →
[inst_1 : Group H] →
[inst_2 : Field K] →
[inst_3 : Field L] →
[inst_4 : Algebra K L] →
[inst_5 : MulSemiringAction G L] →
[inst_6 : MulSemiringAction H L] →
[IsGaloisGroup G K L] → [Finite G] → [IsGaloisGroup H K L] → [Finite H] → G ≃* H | true |
_private.Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal.0.IsCyclotomicExtension.Rat.«_aux_Mathlib_NumberTheory_NumberField_Cyclotomic_Ideal___delab_app__private_Mathlib_NumberTheory_NumberField_Cyclotomic_Ideal_0_IsCyclotomicExtension_Rat_term𝒑_1» | Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal | Lean.PrettyPrinter.Delaborator.Delab | false |
division_def | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a b : G), a / b = a * b⁻¹ | true |
Representation.LinearizeMonoidal.rTensor_comp_δ | Mathlib.RepresentationTheory.Action | ∀ {G : Type v} [inst : Monoid G] {X Y : Action (Type w) G} (Z : Action (Type w) G) {k : Type u}
[inst_1 : CommSemiring k] (f : X ⟶ Y),
(Representation.IntertwiningMap.rTensor (Representation.linearize k G Z) (Representation.linearizeMap f)).comp
(Representation.LinearizeMonoidal.δ X Z) =
(Representation.LinearizeMonoidal.δ Y Z).comp
(Representation.linearizeMap (CategoryTheory.MonoidalCategoryStruct.whiskerRight f Z)) | true |
Matrix.permMatrix_mem_rowStochastic._simp_1 | Mathlib.LinearAlgebra.Matrix.Stochastic | ∀ {R : Type u_1} {n : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R]
[inst_3 : PartialOrder R] [inst_4 : IsOrderedRing R] {σ : Equiv.Perm n},
(Equiv.Perm.permMatrix R σ ∈ Matrix.rowStochastic R n) = True | false |
_private.Mathlib.LinearAlgebra.RootSystem.Hom.0.RootPairing.Equiv.reflection_inv._simp_1_1 | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : 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] {ι₂ : Type u_5} {M₂ : Type u_6} {N₂ : Type u_7}
[inst_5 : AddCommGroup M₂] [inst_6 : Module R M₂] [inst_7 : AddCommGroup N₂] [inst_8 : Module R N₂]
(P : RootPairing ι R M N) (Q : RootPairing ι₂ R M₂ N₂) (e : P.Equiv Q) (m : M),
(↑e).weightMap m = (RootPairing.Equiv.weightEquiv P Q e) m | false |
coe_lt_enorm._simp_1 | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_8} [inst : NNNorm E] {x : E} {r : NNReal}, (↑r < ‖x‖ₑ) = (r < ‖x‖₊) | false |
_private.Lean.Meta.Check.0.Lean.Meta.addPPExplicitToExposeDiff.visit._sparseCasesOn_20 | Lean.Meta.Check | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((data : Lean.MData) → (expr : Lean.Expr) → motive (Lean.Expr.mdata data expr)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
(Nat.hasNotBit 1088 t.ctorIdx → motive t) → motive t | false |
Option.min_eq_some_iff | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : Min α] {o o' : Option α} {a : α}, o ⊓ o' = some a ↔ ∃ b c, o = some b ∧ o' = some c ∧ b ⊓ c = a | true |
Lean.Server.Test.Runner.Client.WidgetInstance.mk.sizeOf_spec | Lean.Server.Test.Runner | ∀ (id : Lean.Name) (javascriptHash : UInt64) (props : Lean.Json),
sizeOf { id := id, javascriptHash := javascriptHash, props := props } =
1 + sizeOf id + sizeOf javascriptHash + sizeOf props | true |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.nodup_insertRupUnits._proof_1 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ} (f : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n)
(units : Std.Sat.CNF.Clause (Std.Tactic.BVDecide.LRAT.Internal.PosFin n))
(i : Fin (f.insertRupUnits units).1.rupUnits.size), ↑i < (f.insertRupUnits units).1.rupUnits.size | false |
Int8.add_neg_eq_sub | Init.Data.SInt.Lemmas | ∀ {a b : Int8}, a + -b = a - b | true |
AddActionHom.fst_apply | Mathlib.GroupTheory.GroupAction.Hom | ∀ (M : Type u_1) (α : Type u_2) (β : Type u_3) [inst : VAdd M α] [inst_1 : VAdd M β],
⇑(AddActionHom.fst M α β) = Prod.fst | true |
ENNReal.zpow_le_of_le | Mathlib.Data.ENNReal.Inv | ∀ {x : ENNReal}, 1 ≤ x → ∀ {a b : ℤ}, a ≤ b → x ^ a ≤ x ^ b | true |
Submodule.mem_of_isLocalized_span | Mathlib.RingTheory.LocalProperties.Submodule | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (s : Set R),
Ideal.span s = ⊤ →
∀ (Mₚ : ↑s → Type u_5) [inst_3 : (r : ↑s) → AddCommMonoid (Mₚ r)] [inst_4 : (r : ↑s) → Module R (Mₚ r)]
(f : (r : ↑s) → M →ₗ[R] Mₚ r) [inst_5 : ∀ (r : ↑s), IsLocalizedModule (Submonoid.powers ↑r) (f r)] {m : M}
{N : Submodule R M}, (∀ (r : ↑s), (f r) m ∈ Submodule.localized₀ (Submonoid.powers ↑r) (f r) N) → m ∈ N | true |
MulAut.congr_symm_apply | Mathlib.Algebra.Group.End | ∀ {G : Type u_3} [inst : Group G] {H : Type u_7} [inst_1 : Group H] (ϕ : G ≃* H) (f : MulAut H),
(MulAut.congr ϕ).symm f = ϕ.trans (MulEquiv.trans f ϕ.symm) | true |
Matrix.nonUnitalNonAssocRing._proof_1 | Mathlib.Data.Matrix.Mul | ∀ {n : Type u_1} {α : Type u_2} [inst : NonUnitalNonAssocRing α] (a b : Matrix n n α), a - b = a + -b | false |
Lean.Compiler.LCNF.Simp.DiscrM.Context._sizeOf_inst | Lean.Compiler.LCNF.Simp.DiscrM | SizeOf Lean.Compiler.LCNF.Simp.DiscrM.Context | false |
Lean.Parser.Term.doCatchMatch.parenthesizer | Lean.Parser.Do | Lean.PrettyPrinter.Parenthesizer | true |
bot_ne_top._simp_2 | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : BoundedOrder α] [Nontrivial α], (⊥ = ⊤) = False | false |
FaithfulSMul.algebraMap_eq_one_iff | Mathlib.Algebra.Algebra.Basic | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] [FaithfulSMul R A]
{r : R}, (algebraMap R A) r = 1 ↔ r = 1 | true |
_private.Init.Data.ByteArray.Lemmas.0.ByteArray.extract_add_one._proof_1_1 | Init.Data.ByteArray.Lemmas | ∀ {a : ByteArray} {i : ℕ}, i + 1 ≤ a.size → ¬min (i + 1) a.size - i = 1 → False | false |
MeasureTheory.measure_inv_smul_sdiff | Mathlib.MeasureTheory.Group.Action | ∀ {G : Type u} {α : Type w} {m : MeasurableSpace α} [inst : Group G] [inst_1 : MulAction G α]
(μ : MeasureTheory.Measure α) [MeasureTheory.SMulInvariantMeasure G α μ] (c : G) (s t : Set α),
μ (c⁻¹ • s \ t) = μ (s \ c • t) | true |
Aesop.SearchM.State.maxRuleApplicationDepthReached | Aesop.Search.SearchM | {Q : Type} → [inst : Aesop.Queue Q] → Aesop.SearchM.State Q → Bool | true |
MagmaCat.Hom.casesOn | Mathlib.Algebra.Category.Semigrp.Basic | {A B : MagmaCat} →
{motive : A.Hom B → Sort u_1} → (t : A.Hom B) → ((hom' : ↑A →ₙ* ↑B) → motive { hom' := hom' }) → motive t | false |
Std.Time.PlainDateTime.ext | Std.Time.DateTime.PlainDateTime | ∀ {x y : Std.Time.PlainDateTime}, x.date = y.date → x.time = y.time → x = y | true |
continuousSubmonoid._proof_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ (α : Type u_1) (β : Type u_2) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : MulOneClass β]
[ContinuousMul β] {a b : α → β}, a ∈ {f | Continuous f} → b ∈ {f | Continuous f} → Continuous (a * b) | false |
Mathlib.Tactic.Sat.LClause.ctorIdx | Mathlib.Tactic.Sat.FromLRAT | Mathlib.Tactic.Sat.LClause → ℕ | false |
signedDist._proof_8 | Mathlib.Geometry.Euclidean.SignedDist | ContinuousAdd ℝ | false |
CategoryTheory.Limits.Cocone.rec | Mathlib.CategoryTheory.Limits.Cones | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
{motive : CategoryTheory.Limits.Cocone F → Sort u} →
((pt : C) → (ι : F ⟶ (CategoryTheory.Functor.const J).obj pt) → motive { pt := pt, ι := ι }) →
(t : CategoryTheory.Limits.Cocone F) → motive t | false |
Lean.Meta.Match.MatcherInfo.getAltRange | Lean.Meta.Match.MatcherInfo | Lean.Meta.MatcherInfo → Std.Rco ℕ | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.