name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
not_finite_iff_infinite._simp_1 | Mathlib.Data.Finite.Defs | ∀ {α : Sort u_1}, (¬Finite α) = Infinite α | false |
Affine.Simplex.sum_centroidWeightsWithCircumcenter | Mathlib.Geometry.Euclidean.Circumcenter | ∀ {n : ℕ} {fs : Finset (Fin (n + 1))}, fs.Nonempty → ∑ i, Affine.Simplex.centroidWeightsWithCircumcenter fs i = 1 | true |
Std.DHashMap.Const.getKey!_filterMap | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {γ : Type w} {m : Std.DHashMap α fun x => β}
[inst : EquivBEq α] [inst_1 : LawfulHashable α] [inst_2 : Inhabited α] {f : α → β → Option γ} {k : α},
(Std.DHashMap.filterMap f m).getKey! k =
((m.getKey? k).pfilter fun x_2 h' => (f x_2 (Std.DHashMap.Const.get m x_2 ⋯)).isSome).get! | true |
Algebra.ofSubsemiring | Mathlib.Algebra.Algebra.Basic | {R : Type u_1} →
{A : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[Algebra R A] →
{C : Type u_4} → [inst_3 : SetLike C R] → [inst_4 : SubsemiringClass C R] → (S : C) → Algebra (↥S) A | true |
CategoryTheory.Sheaf.ΓNatIsoCoyoneda | Mathlib.CategoryTheory.Sites.GlobalSections | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(X : Type (max u v)) →
[Unique X] →
CategoryTheory.Sheaf.Γ J (Type (max u v)) ≅
CategoryTheory.coyoneda.obj (Opposite.op ((CategoryTheory.constantSheaf J (Type (max u v))).obj X)) | true |
NormedField.valuation | Mathlib.Topology.Algebra.Valued.NormedValued | {K : Type u_1} → [hK : NormedField K] → [IsUltrametricDist K] → Valuation K NNReal | true |
Std.DTreeMap.getKey_union_of_not_mem_right | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k : α} (not_mem : k ∉ t₂) {h' : k ∈ t₁ ∪ t₂}, (t₁ ∪ t₂).getKey k h' = t₁.getKey k ⋯ | true |
CompactlyCoherentSpace.isCoherentWith | Mathlib.Topology.Compactness.CompactlyCoherentSpace | ∀ {X : Type u_1} {inst : TopologicalSpace X} [self : CompactlyCoherentSpace X],
Topology.IsCoherentWith {K | IsCompact K} | true |
ValuedCSP.Term.mk.sizeOf_spec | Mathlib.Combinatorics.Optimization.ValuedCSP | ∀ {D : Type u_1} {C : Type u_2} [inst : AddCommMonoid C] [inst_1 : PartialOrder C] [inst_2 : IsOrderedAddMonoid C]
{Γ : ValuedCSP D C} {ι : Type u_3} [inst_3 : SizeOf D] [inst_4 : SizeOf C]
[inst_5 : (a : (n : ℕ) × ((Fin n → D) → C)) → SizeOf (Γ a)] [inst_6 : SizeOf ι] (n : ℕ) (f : (Fin n → D) → C)
(inΓ : ⟨n, f⟩ ∈ Γ) (app : Fin n → ι), sizeOf { n := n, f := f, inΓ := inΓ, app := app } = 1 + sizeOf n + sizeOf inΓ | true |
CategoryTheory.Functor.CoconeTypes.precompose | Mathlib.CategoryTheory.Limits.Types.ColimitType | {J : Type u} →
[inst : CategoryTheory.Category.{v, u} J] →
{F : CategoryTheory.Functor J (Type w₀)} →
F.CoconeTypes →
{G : CategoryTheory.Functor J (Type w₀')} →
(app : (j : J) → G.obj j → F.obj j) →
(∀ {j j' : J} (f : j ⟶ j'), app j' ∘ G.map f = F.map f ∘ app j) → G.CoconeTypes | true |
IsAdjoinRoot.mk.congr_simp | Mathlib.RingTheory.IsAdjoinRoot | ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] {f : Polynomial R}
(map map_1 : Polynomial R →ₐ[R] S) (e_map : map = map_1) (map_surjective : Function.Surjective ⇑map)
(ker_map : RingHom.ker map = Ideal.span {f}),
{ map := map, map_surjective := map_surjective, ker_map := ker_map } =
{ map := map_1, map_surjective := ⋯, ker_map := ⋯ } | true |
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.testBit_two_pow_sub_succ._simp_1_4 | Init.Data.Nat.Bitwise.Lemmas | ∀ {a b : ℕ}, (a.succ < b.succ) = (a < b) | false |
Ordnode.Valid'.balanceR_aux | Mathlib.Data.Ordmap.Ordset | ∀ {α : Type u_1} [inst : Preorder α] {l : Ordnode α} {x : α} {r : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α},
Ordnode.Valid' o₁ l ↑x →
Ordnode.Valid' (↑x) r o₂ →
(r.size = 0 → l.size ≤ 1) →
(1 ≤ r.size → 1 ≤ l.size → l.size ≤ Ordnode.delta * r.size) →
2 * r.size ≤ 9 * l.size + 5 ∨ r.size ≤ 3 → Ordnode.Valid' o₁ (l.balanceR x r) o₂ | true |
IsPrimitiveRoot.integralPowerBasis.eq_1 | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {n : ℕ} {K : Type u} [inst : Field K] {ζ : K} [inst_1 : NeZero n] [inst_2 : CharZero K]
[inst_3 : IsCyclotomicExtension {n} ℚ K] (hζ : IsPrimitiveRoot ζ n),
hζ.integralPowerBasis = (Algebra.adjoin.powerBasis' ⋯).map hζ.adjoinEquivRingOfIntegers | true |
Localization.localAlgHom_apply | Mathlib.RingTheory.Localization.AtPrime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] {P : Type u_3}
[inst_3 : CommSemiring P] [inst_4 : Algebra R P] (I : Ideal S) [inst_5 : I.IsPrime] (J : Ideal P) [inst_6 : J.IsPrime]
(f : S →ₐ[R] P) (hIJ : I = Ideal.comap f J) (x : Localization.AtPrime I),
(Localization.localAlgHom I J f hIJ) x = (Localization.localRingHom I J f.toRingHom hIJ) x | true |
Aesop.RuleTac.ForwardM.State.ctorIdx | Aesop.RuleTac.Forward | Aesop.RuleTac.ForwardM.State → ℕ | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.Assignment.instToString.match_1.eq_2 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound | ∀ (motive : Std.Tactic.BVDecide.LRAT.Internal.Assignment → Sort u_1)
(h_1 : Unit → motive Std.Tactic.BVDecide.LRAT.Internal.Assignment.pos)
(h_2 : Unit → motive Std.Tactic.BVDecide.LRAT.Internal.Assignment.neg)
(h_3 : Unit → motive Std.Tactic.BVDecide.LRAT.Internal.Assignment.both)
(h_4 : Unit → motive Std.Tactic.BVDecide.LRAT.Internal.Assignment.unassigned),
(match Std.Tactic.BVDecide.LRAT.Internal.Assignment.neg with
| Std.Tactic.BVDecide.LRAT.Internal.Assignment.pos => h_1 ()
| Std.Tactic.BVDecide.LRAT.Internal.Assignment.neg => h_2 ()
| Std.Tactic.BVDecide.LRAT.Internal.Assignment.both => h_3 ()
| Std.Tactic.BVDecide.LRAT.Internal.Assignment.unassigned => h_4 ()) =
h_2 () | true |
Polynomial.Chebyshev.T_neg_two | Mathlib.RingTheory.Polynomial.Chebyshev | ∀ (R : Type u_1) [inst : CommRing R], Polynomial.Chebyshev.T R (-2) = 2 * Polynomial.X ^ 2 - 1 | true |
_private.Mathlib.SetTheory.Ordinal.Family.0.Ordinal.lt_blsub_iff._simp_1_1 | Mathlib.SetTheory.Ordinal.Family | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | false |
SimpleGraph.CompleteEquipartiteSubgraph.card_parts | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {V : Type u_1} {G : SimpleGraph V} {r t : ℕ} (self : G.CompleteEquipartiteSubgraph r t), self.parts.card = r ∨ t = 0 | true |
Aesop.instReprStrategy | Aesop.Options.Public | Repr Aesop.Strategy | true |
Std.DTreeMap.Internal.Impl.Equiv.beq_congr | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] [inst_1 : (k : α) → BEq (β k)] {m₃ m₄ : Std.DTreeMap.Internal.Impl α β},
m₁.WF → m₂.WF → m₃.WF → m₄.WF → m₁.Equiv m₃ → m₂.Equiv m₄ → m₁.beq m₂ = m₃.beq m₄ | true |
Lean.IR.Log.toString | Lean.Compiler.IR.CompilerM | Lean.IR.Log → String | true |
CategoryTheory.Adjunction.Quadruple._sizeOf_1 | Mathlib.CategoryTheory.Adjunction.Quadruple | {C : Type u₁} →
{D : Type u₂} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
{L : CategoryTheory.Functor C D} →
{F : CategoryTheory.Functor D C} →
{G : CategoryTheory.Functor C D} →
{R : CategoryTheory.Functor D C} →
[SizeOf C] → [SizeOf D] → CategoryTheory.Adjunction.Quadruple L F G R → ℕ | false |
isBot_toDual_iff | Mathlib.Order.Max | ∀ {α : Type u_1} [inst : LE α] {a : α}, IsBot (OrderDual.toDual a) ↔ IsTop a | true |
Dist.mk | Mathlib.Topology.MetricSpace.Pseudo.Defs | {α : Type u_3} → (α → α → ℝ) → Dist α | true |
MvPolynomial.universalFactorizationMapPresentation_jacobiMatrix | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ (R : Type u_1) [inst : CommRing R] (n m k : ℕ) (hn : n = m + k),
(MvPolynomial.universalFactorizationMapPresentation R n m k hn).jacobiMatrix =
-((Matrix.reindex (finCongr ⋯) (finCongr ⋯))
((Polynomial.map
((MvPolynomial.mapAlgHom (Algebra.ofId R (MvPolynomial (Fin n) R))).comp
(MvPolynomial.rename Sum.inl)).toRingHom
(Polynomial.freeMonic R m)).sylvester
(Polynomial.map
((MvPolynomial.mapAlgHom (Algebra.ofId R (MvPolynomial (Fin n) R))).comp
(MvPolynomial.rename Sum.inr)).toRingHom
(Polynomial.freeMonic R k))
m k)).transpose | true |
_private.Mathlib.Algebra.Category.Grp.LeftExactFunctor.0.AddCommGrpCat.leftExactFunctorForgetEquivalence.instBraidedCategory | Mathlib.Algebra.Category.Grp.LeftExactFunctor | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasFiniteBiproducts C] → CategoryTheory.BraidedCategory C | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.getElem!_toArray_rcc_eq_zero_iff._simp_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ}, ((m...n).toArray[i]! = 0) = (n ≤ i + m ∨ m = 0 ∧ i = 0) | false |
Mathlib.Tactic.Sat.buildReify.reifyClause1 | Mathlib.Tactic.Sat.FromLRAT | ℕ → Lean.Expr → Lean.Expr × Lean.Expr | true |
ProfiniteGrp.profiniteCompletion._proof_4 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Completion | ∀ {X Y Z : GrpCat} (f : X ⟶ Y) (g : Y ⟶ Z),
ProfiniteGrp.ProfiniteCompletion.lift
(CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g)
(ProfiniteGrp.ProfiniteCompletion.eta Z)) =
CategoryTheory.CategoryStruct.comp
(ProfiniteGrp.ProfiniteCompletion.lift
(CategoryTheory.CategoryStruct.comp f (ProfiniteGrp.ProfiniteCompletion.eta Y)))
(ProfiniteGrp.ProfiniteCompletion.lift
(CategoryTheory.CategoryStruct.comp g (ProfiniteGrp.ProfiniteCompletion.eta Z))) | false |
RootPairing.rootForm_self_eq_zero_iff | 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 : LinearOrder R] [IsStrictOrderedRing R] [inst_6 : Module R M]
[inst_7 : Module R N] (P : RootPairing ι R M N) {x : M}, (P.RootForm x) x = 0 ↔ x ∈ LinearMap.ker P.RootForm | true |
Std.Time.instHAddOffsetOffset_41 | Std.Time.Date.Basic | HAdd Std.Time.Week.Offset Std.Time.Day.Offset Std.Time.Day.Offset | true |
AddConjClasses.instDecidableEqOfDecidableRelIsAddConj | Mathlib.Algebra.Group.Conj | {α : Type u} → [inst : AddMonoid α] → [DecidableRel IsAddConj] → DecidableEq (AddConjClasses α) | true |
Lean.IR.Sorry.State.noConfusionType | Lean.Compiler.IR.Sorry | Sort u → Lean.IR.Sorry.State → Lean.IR.Sorry.State → Sort u | false |
PreAbstractSimplicialComplex.instInfSet.match_1 | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | ∀ (ι : Type u_1) (s : Set (PreAbstractSimplicialComplex ι)) {x : Finset ι}
(motive : x ∈ (⋂ K ∈ s, K.faces) ∩ {t | t.Nonempty} → Prop) (x_1 : x ∈ (⋂ K ∈ s, K.faces) ∩ {t | t.Nonempty}),
(∀ (hx : x ∈ ⋂ K ∈ s, K.faces) (hn : x ∈ {t | t.Nonempty}), motive ⋯) → motive x_1 | false |
Lean.Widget.PanelWidgetsExtEntry._sizeOf_1 | Lean.Widget.UserWidget | Lean.Widget.PanelWidgetsExtEntry → ℕ | false |
_private.Mathlib.LinearAlgebra.Dual.Lemmas.0.Module.instIsReflexiveOfFiniteOfProjective.match_1 | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ (R : Type u_2) (N : Type u_1) [inst : CommSemiring R] [inst_1 : AddCommMonoid N] [inst_2 : Module R N] (w : ℕ)
(f : (Fin w → R) →ₗ[R] N) (motive : (∃ h, f ∘ₗ h = LinearMap.id) → Prop) (x : ∃ h, f ∘ₗ h = LinearMap.id),
(∀ (g : N →ₗ[R] Fin w → R) (H : f ∘ₗ g = LinearMap.id), motive ⋯) → motive x | false |
Shrink.instIsRightCancelAdd | Mathlib.Algebra.Group.Shrink | ∀ {α : Type u_2} [inst : Small.{v, u_2} α] [inst_1 : Add α] [IsRightCancelAdd α], IsRightCancelAdd (Shrink.{v, u_2} α) | true |
Lean.Expr.FoldConstsImpl.State.noConfusion | Lean.Util.FoldConsts | {P : Sort u} → {t t' : Lean.Expr.FoldConstsImpl.State} → t = t' → Lean.Expr.FoldConstsImpl.State.noConfusionType P t t' | false |
Lean.Meta.Grind.AC.DiseqCnstrProof.brecOn.eq | Lean.Meta.Tactic.Grind.AC.Types | ∀ {motive_1 : Lean.Meta.Grind.AC.DiseqCnstr → Sort u} {motive_2 : Lean.Meta.Grind.AC.DiseqCnstrProof → Sort u}
(t : Lean.Meta.Grind.AC.DiseqCnstrProof) (F_1 : (t : Lean.Meta.Grind.AC.DiseqCnstr) → t.below → motive_1 t)
(F_2 : (t : Lean.Meta.Grind.AC.DiseqCnstrProof) → t.below → motive_2 t),
t.brecOn F_1 F_2 = F_2 t (Lean.Meta.Grind.AC.DiseqCnstrProof.brecOn.go t F_1 F_2).2 | true |
Array.PrefixTable.noConfusionType | Batteries.Data.Array.Match | Sort u → {α : Type u_1} → Array.PrefixTable α → {α' : Type u_1} → Array.PrefixTable α' → Sort u | false |
CochainComplex.homologyMap_exact₂_of_distTriang | Mathlib.Algebra.Homology.DerivedCategory.HomologySequence | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : HasDerivedCategory C] (T : CategoryTheory.Pretriangulated.Triangle (CochainComplex C ℤ))
(hT : DerivedCategory.Q.mapTriangle.obj T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles) (n : ℤ),
{ X₁ := HomologicalComplex.homology T.obj₁ n, X₂ := HomologicalComplex.homology T.obj₂ n,
X₃ := HomologicalComplex.homology T.obj₃ n, f := HomologicalComplex.homologyMap T.mor₁ n,
g := HomologicalComplex.homologyMap T.mor₂ n, zero := ⋯ }.Exact | true |
Filter.IsCountablyGenerated.casesOn | Mathlib.Order.Filter.CountablyGenerated | {α : Type u_1} →
{f : Filter α} →
{motive : f.IsCountablyGenerated → Sort u} →
(t : f.IsCountablyGenerated) → ((out : ∃ s, s.Countable ∧ f = Filter.generate s) → motive ⋯) → motive t | false |
MeasureTheory.measureReal_prod_prod | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] (s : Set α) (t : Set β),
(μ.prod ν).real (s ×ˢ t) = μ.real s * ν.real t | true |
Lean.Meta.Sym.SimpGoalResult.closed.elim | Lean.Meta.Sym.Simp.Goal | {motive : Lean.Meta.Sym.SimpGoalResult → Sort u} →
(t : Lean.Meta.Sym.SimpGoalResult) → t.ctorIdx = 1 → motive Lean.Meta.Sym.SimpGoalResult.closed → motive t | false |
RingHom.star_def | Mathlib.Algebra.Star.Basic | ∀ {R : Type u} [inst : CommSemiring R] [inst_1 : StarRing R] {S : Type u_1} [inst_2 : NonAssocSemiring S] (f : S →+* R),
star f = (starRingEnd R).comp f | true |
BitVec.toNat_umod | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} {x y : BitVec n}, (x % y).toNat = x.toNat % y.toNat | true |
CategoryTheory.objUp_objDown | Mathlib.CategoryTheory.Category.ULift | ∀ {C : Type u_1} (A : CategoryTheory.ULiftHom C), CategoryTheory.ULiftHom.objUp A.objDown = A | true |
ZNum.cast_bit1 | Mathlib.Data.Num.ZNum | ∀ {α : Type u_1} [inst : AddGroupWithOne α] (n : ZNum), ↑n.bit1 = ↑n + ↑n + 1 | true |
Zsqrtd.linearOrder._proof_5 | Mathlib.NumberTheory.Zsqrtd.Basic | ∀ {d : ℕ} (a b : ℤ√↑d), compareOfLessAndEq a b = compareOfLessAndEq a b | false |
eventually_norm_pow_le | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedRing α] (a : α), ∀ᶠ (n : ℕ) in Filter.atTop, ‖a ^ n‖ ≤ ‖a‖ ^ n | true |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.ensureType.match_1 | Lean.Meta.LetToHave | (motive : Lean.Expr → Sort u_1) →
(__discr : Lean.Expr) → ((u : Lean.Level) → motive (Lean.Expr.sort u)) → ((x : Lean.Expr) → motive x) → motive __discr | false |
Lean.JsonRpc.MessageKind.noConfusion | Lean.Data.JsonRpc | {P : Sort v✝} → {x y : Lean.JsonRpc.MessageKind} → x = y → Lean.JsonRpc.MessageKind.noConfusionType P x y | false |
TopCat.isEmbedding_of_pullback | Mathlib.Topology.Category.TopCat.Limits.Pullbacks | ∀ {X Y S : TopCat} {f : X ⟶ S} {g : Y ⟶ S},
Topology.IsEmbedding ⇑(CategoryTheory.ConcreteCategory.hom f) →
Topology.IsEmbedding ⇑(CategoryTheory.ConcreteCategory.hom g) →
Topology.IsEmbedding
⇑(CategoryTheory.ConcreteCategory.hom
(CategoryTheory.Limits.limit.π (CategoryTheory.Limits.cospan f g) CategoryTheory.Limits.WalkingCospan.one)) | true |
Function.Injective.isCancelAdd | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_1} {M₂ : Type u_2} [inst : Add M₁] [inst_1 : Add M₂] [IsCancelAdd M₂] (f : M₁ → M₂),
Function.Injective f → (∀ (x y : M₁), f (x + y) = f x + f y) → IsCancelAdd M₁ | true |
Orientation.inner_eq_zero_iff_eq_zero_or_eq_smul_rotation_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) {x y : V}, inner ℝ x y = 0 ↔ x = 0 ∨ ∃ r, r • (o.rotation ↑(Real.pi / 2)) x = y | true |
Lean.Firefox.instFromJsonProfile.fromJson | Lean.Util.Profiler | Lean.Json → Except String Lean.Firefox.Profile | true |
_aux_Init_NotationExtra___macroRules_tacticFunext____1 | Init.NotationExtra | Lean.Macro | false |
DividedPowers.SubDPIdeal.instBot._proof_1 | Mathlib.RingTheory.DividedPowers.SubDPIdeal | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} {hI : DividedPowers I} (x : ℕ),
x ≠ 0 → ∀ x_1 ∈ ⊥, hI.dpow x x_1 ∈ ⊥ | false |
HasFDerivAt.sqrt | Mathlib.Analysis.SpecialFunctions.Sqrt | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {x : E} {f' : StrongDual ℝ E},
HasFDerivAt f f' x → f x ≠ 0 → HasFDerivAt (fun y => √(f y)) ((1 / (2 * √(f x))) • f') x | true |
CategoryTheory.Cat.HasLimits.homDiagram_map | Mathlib.CategoryTheory.Category.Cat.Limit | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J CategoryTheory.Cat}
(X Y : CategoryTheory.Limits.limit (F.comp CategoryTheory.Cat.objects)) {X_1 Y_1 : J} (f : X_1 ⟶ Y_1)
(g :
CategoryTheory.Limits.limit.π (F.comp CategoryTheory.Cat.objects) X_1 X ⟶
CategoryTheory.Limits.limit.π (F.comp CategoryTheory.Cat.objects) X_1 Y),
(CategoryTheory.Cat.HasLimits.homDiagram X Y).map f g =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
(CategoryTheory.CategoryStruct.comp ((F.map f).toFunctor.map g) (CategoryTheory.eqToHom ⋯)) | true |
CategoryTheory.StrictlyUnitaryLaxFunctor.mapIdIso_inv | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.StrictlyUnitaryLaxFunctor B C) (x : B), (F.mapIdIso x).inv = CategoryTheory.eqToHom ⋯ | true |
UniqueFactorizationMonoid.multiplicative_prime_power | Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicative | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [UniqueFactorizationMonoid α] {β : Type u_3}
[inst_2 : CommMonoidWithZero β] {f : α → β} (s : Finset α) (i j : α → ℕ),
(∀ p ∈ s, Prime p) →
(∀ p ∈ s, ∀ q ∈ s, p ∣ q → p = q) →
(∀ {x y : α}, IsUnit y → f (x * y) = f x * f y) →
(∀ {p : α} (i : ℕ), Prime p → f (p ^ i) = f p ^ i) →
(∀ {x y : α}, IsRelPrime x y → f (x * y) = f x * f y) →
f (∏ p ∈ s, p ^ (i p + j p)) = f (∏ p ∈ s, p ^ i p) * f (∏ p ∈ s, p ^ j p) | true |
Subalgebra.map_le | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] {S : Subalgebra R A} {f : A →ₐ[R] B} {U : Subalgebra R B},
Subalgebra.map f S ≤ U ↔ S ≤ Subalgebra.comap f U | true |
DirectLimit.instDistribSMulOfMulActionHomClass._proof_1 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {R : Type u_4} {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (i : ι) → AddZeroClass (G i)] [inst_6 : (i : ι) → DistribSMul R (G i)]
[inst_7 : ∀ (i j : ι) (h : i ≤ j), AddMonoidHomClass (T h) (G i) (G j)]
[inst_8 : ∀ (i j : ι) (h : i ≤ j), MulActionHomClass (T h) R (G i) (G j)] (r : R) (i : ι) (x x_1 : G i),
r • (⟦⟨i, x⟩⟧ + ⟦⟨i, x_1⟩⟧) = r • ⟦⟨i, x⟩⟧ + r • ⟦⟨i, x_1⟩⟧ | false |
IsCompactlyGenerated.BooleanGenerators.mk | Mathlib.Order.BooleanGenerators | ∀ {α : Type u_1} [inst : CompleteLattice α] {S : Set α},
(∀ I ∈ S, IsAtom I) →
(∀ (s : Finset α) (a : α), ↑s ⊆ S → IsCompactElement a → a ≤ s.sup id → ∃ t ⊆ s, a = t.sup id) →
IsCompactlyGenerated.BooleanGenerators S | true |
HolorIndex.cast_type | Mathlib.Data.Holor | ∀ {ds₁ ds₂ : List ℕ} (is : List ℕ) (eq : ds₁ = ds₂) (h : List.Forall₂ (fun x1 x2 => x1 < x2) is ds₁),
↑(cast ⋯ ⟨is, h⟩) = is | true |
IsTopologicalRing.toIsTopologicalSemiring | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} {inst : TopologicalSpace R} {inst_1 : NonUnitalNonAssocRing R} [self : IsTopologicalRing R],
IsTopologicalSemiring R | true |
Aesop.Stats._sizeOf_inst | Aesop.Stats.Basic | SizeOf Aesop.Stats | false |
Turing.TM1to1.tr | Mathlib.Computability.TuringMachine.PostTuringMachine | {Γ : Type u_1} →
{Λ : Type u_2} →
{σ : Type u_3} →
{n : ℕ} →
(Γ → List.Vector Bool n) →
(List.Vector Bool n → Γ) →
(Λ → Turing.TM1.Stmt Γ Λ σ) → Turing.TM1to1.Λ' Γ Λ σ → Turing.TM1.Stmt Bool (Turing.TM1to1.Λ' Γ Λ σ) σ | true |
ZMod.instIsAddCyclic | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ (n : ℕ), IsAddCyclic (ZMod n) | true |
Lean.Parser.Command.syntaxCat._regBuiltin.Lean.Parser.Command.syntaxCat_1 | Lean.Parser.Syntax | IO Unit | false |
AlgebraicGeometry.tilde.adjunction._proof_1 | Mathlib.AlgebraicGeometry.Modules.Tilde | ∀ {R : CommRingCat} (M : ModuleCat ↑R),
CategoryTheory.CategoryStruct.comp
((AlgebraicGeometry.tilde.functor R).map (AlgebraicGeometry.tilde.toTildeΓNatIso.hom.app M))
(AlgebraicGeometry.Scheme.Modules.fromTildeΓNatTrans.app ((AlgebraicGeometry.tilde.functor R).obj M)) =
CategoryTheory.CategoryStruct.id ((AlgebraicGeometry.tilde.functor R).obj M) | false |
_private.Qq.Match.0.Qq._aux_Qq_Match___macroRules_Lean_Parser_Term_match_1.match_3 | Qq.Match | (motive : Option (Array (Lean.TSyntax `term)) → Sort u_1) →
(x : Option (Array (Lean.TSyntax `term))) →
((patss : Array (Lean.TSyntax `term)) → motive (some patss)) → (Unit → motive none) → motive x | false |
Affine.Simplex.excenter | Mathlib.Geometry.Euclidean.Incenter | {V : Type u_1} →
{P : Type u_2} →
[inst : NormedAddCommGroup V] →
[inst_1 : InnerProductSpace ℝ V] →
[inst_2 : MetricSpace P] →
[inst_3 : NormedAddTorsor V P] → {n : ℕ} → [NeZero n] → Affine.Simplex ℝ P n → Finset (Fin (n + 1)) → P | true |
_private.Mathlib.Data.Nat.Log.0.Nat.clog_of_one_lt._proof_1_4 | Mathlib.Data.Nat.Log | ∀ {b n : ℕ}, 1 < b → ∀ (c : ℕ), n ≤ b ^ c * b ↔ n + b - 1 ≤ b ^ c * b + b - 1 | false |
Lean.Server.Test.Runner.Client.MsgEmbed.below_4 | Lean.Server.Test.Runner | {motive_1 : Lean.Server.Test.Runner.Client.MsgEmbed → Sort u} →
{motive_2 : Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed → Sort u} →
{motive_3 :
Lean.Server.Test.Runner.Client.StrictOrLazy
(Array (Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed)) Lean.Lsp.RpcRef →
Sort u} →
{motive_4 : Array (Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed) → Sort u} →
{motive_5 : List (Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed) → Sort u} →
List (Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed) → Sort (max 1 u) | false |
Int64.decEq._proof_2 | Init.Data.SInt.Basic | ∀ (n m : UInt64), ¬n = m → { toUInt64 := n } = { toUInt64 := m } → False | false |
_private.Lean.Meta.Match.Basic.0.Lean.Meta.Match.Pattern.toExpr.visit | Lean.Meta.Match.Basic | Bool → Lean.Meta.Match.Pattern → Lean.MetaM Lean.Expr | true |
CategoryTheory.NatIso.mapHomologicalComplex._proof_2 | Mathlib.Algebra.Homology.Additive | ∀ {ι : Type u_1} {W₁ : Type u_2} {W₂ : Type u_5} [inst : CategoryTheory.Category.{u_3, u_2} W₁]
[inst_1 : CategoryTheory.Category.{u_4, u_5} W₂] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms W₁]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms W₂] {F G : CategoryTheory.Functor W₁ W₂}
[inst_4 : F.PreservesZeroMorphisms] [inst_5 : G.PreservesZeroMorphisms] (α : F ≅ G) (c : ComplexShape ι),
CategoryTheory.CategoryStruct.comp (CategoryTheory.NatTrans.mapHomologicalComplex α.hom c)
(CategoryTheory.NatTrans.mapHomologicalComplex α.inv c) =
CategoryTheory.CategoryStruct.id (F.mapHomologicalComplex c) | false |
LinearEquiv.instZero._proof_1 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R : Type u_3} {R₂ : Type u_4} {M : Type u_2} {M₂ : Type u_1} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
(x y : M), (LinearMap.toAddHom 0).toFun (x + y) = (LinearMap.toAddHom 0).toFun x + (LinearMap.toAddHom 0).toFun y | false |
Lean.Widget.PanelWidgetInstance.mk.inj | Lean.Widget.UserWidget | ∀ {toWidgetInstance : Lean.Widget.WidgetInstance} {range? : Option Lean.Lsp.Range} {name? : Option String}
{toWidgetInstance_1 : Lean.Widget.WidgetInstance} {range?_1 : Option Lean.Lsp.Range} {name?_1 : Option String},
{ toWidgetInstance := toWidgetInstance, range? := range?, name? := name? } =
{ toWidgetInstance := toWidgetInstance_1, range? := range?_1, name? := name?_1 } →
toWidgetInstance = toWidgetInstance_1 ∧ range? = range?_1 ∧ name? = name?_1 | true |
Lean.Grind.Ring.OfSemiring.r_trans | Init.Grind.Ring.Envelope | ∀ {α : Type u} [inst : Lean.Grind.Semiring α] {a b c : α × α},
Lean.Grind.Ring.OfSemiring.r α a b → Lean.Grind.Ring.OfSemiring.r α b c → Lean.Grind.Ring.OfSemiring.r α a c | true |
CategoryTheory.Abelian.SpectralObject.descOpcycles.congr_simp | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) (n₀ n₀_1 : ℤ) (e_n₀ : n₀ = n₀_1)
(n₁ : ℤ) (hn₁ : n₀ + 1 = n₁) {A : C} (x x_1 : (X.H n₁).obj (CategoryTheory.ComposableArrows.mk₁ f) ⟶ A)
(e_x : x = x_1) (hx : CategoryTheory.CategoryStruct.comp (X.δ f g n₀ n₁ hn₁) x = 0),
X.descOpcycles f g n₀ n₁ hn₁ x hx = X.descOpcycles f g n₀_1 n₁ ⋯ x_1 ⋯ | true |
cfcₙ_le_iff._auto_5 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | false |
_private.Mathlib.RingTheory.Localization.Away.Basic.0.IsLocalization.Away.map_surjective_iff._simp_1_4 | Mathlib.RingTheory.Localization.Away.Basic | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | false |
_private.Std.Data.Iterators.Lemmas.Combinators.Zip.0.Std.Iter.atIdxSlow?_eq_match.match_1.eq_2 | Std.Data.Iterators.Lemmas.Combinators.Zip | ∀ (motive : ℕ → Sort u_1) (n : ℕ) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match n.succ with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_2 n | true |
RightCancelSemigroup.casesOn | Mathlib.Algebra.Group.Defs | {G : Type u} →
{motive : RightCancelSemigroup G → Sort u_1} →
(t : RightCancelSemigroup G) →
([toSemigroup : Semigroup G] →
[toIsRightCancelMul : IsRightCancelMul G] →
motive { toSemigroup := toSemigroup, toIsRightCancelMul := toIsRightCancelMul }) →
motive t | false |
Lean.Lsp.RefIdent.recOn | Lean.Data.Lsp.Internal | {motive : Lean.Lsp.RefIdent → Sort u} →
(t : Lean.Lsp.RefIdent) →
((moduleName identName : String) → motive (Lean.Lsp.RefIdent.const moduleName identName)) →
((moduleName id : String) → motive (Lean.Lsp.RefIdent.fvar moduleName id)) → motive t | false |
abs_mul_self | Mathlib.Algebra.Order.Ring.Abs | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : LinearOrder α] [IsOrderedRing α] (a : α), |a * a| = a * a | true |
CategoryTheory.MorphismProperty.IsInvertedBy.iff_of_iso | Mathlib.CategoryTheory.MorphismProperty.IsInvertedBy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(W : CategoryTheory.MorphismProperty C) {F₁ F₂ : CategoryTheory.Functor C D} (e : F₁ ≅ F₂),
W.IsInvertedBy F₁ ↔ W.IsInvertedBy F₂ | true |
Finset.card_le_card_mul_self | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : Mul α] [IsLeftCancelMul α] [inst_2 : DecidableEq α] {s : Finset α}, s.card ≤ (s * s).card | true |
Lean.Grind.CommRing.Expr.denoteS_toPolyS | Init.Grind.Ring.CommSemiringAdapter | ∀ {α : Type u_1} [inst : Lean.Grind.CommSemiring α] (ctx : Lean.Grind.CommRing.Context α)
(e : Lean.Grind.CommRing.Expr),
Lean.Grind.CommRing.Poly.denoteS ctx e.toPolyS = Lean.Grind.CommRing.Expr.denoteS ctx e | true |
CochainComplex.HomComplex.Cochain.single_v_eq_zero | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} {p q : ℤ} (f : K.X p ⟶ L.X q) (n p' q' : ℤ) (hpq' : p' + n = q'),
p' ≠ p → (CochainComplex.HomComplex.Cochain.single f n).v p' q' hpq' = 0 | true |
AbsoluteValue.IsAdmissible.mk | Mathlib.NumberTheory.ClassNumber.AdmissibleAbsoluteValue | {R : Type u_1} →
[inst : EuclideanDomain R] →
{abv : AbsoluteValue R ℤ} →
abv.IsEuclidean →
(card : ℝ → ℕ) →
(∀ (n : ℕ) {ε : ℝ},
0 < ε →
∀ {b : R},
b ≠ 0 →
∀ (A : Fin n → R), ∃ t, ∀ (i₀ i₁ : Fin n), t i₀ = t i₁ → ↑(abv (A i₁ % b - A i₀ % b)) < abv b • ε) →
abv.IsAdmissible | true |
Std.Time.Nanosecond.Ordinal.instTransOrdOfDay | Std.Time.Time.Unit.Nanosecond | Std.TransOrd Std.Time.Nanosecond.Ordinal.OfDay | true |
CategoryTheory.ComposableArrows.Precomp.obj_one | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n)
(X : C), CategoryTheory.ComposableArrows.Precomp.obj F X 1 = F.obj' 0 ⋯ | true |
RingCat.Colimits.ColimitType.AddGroupWithOne | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
(F : CategoryTheory.Functor J RingCat) → AddGroupWithOne (RingCat.Colimits.ColimitType F) | true |
TopologicalSpace.IrreducibleCloseds.mk_singleton | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_2} [inst : TopologicalSpace α] [inst_1 : T1Space α] {x : α},
{ carrier := {x}, isIrreducible' := ⋯, isClosed' := ⋯ } = {x} | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.