name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
AdicCompletion.AdicCauchySequence.instSMulNat | Mathlib.RingTheory.AdicCompletion.Basic | {R : Type u_1} →
[inst : CommRing R] →
(I : Ideal R) →
(M : Type u_4) →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → SMul ℕ (AdicCompletion.AdicCauchySequence I M) | true |
_private.Init.Data.SInt.Lemmas.0.Int32.ofNat_add._simp_1_1 | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, Int32.ofNat n = Int32.ofInt ↑n | false |
Pi.constNonUnitalRingHom._proof_1 | Mathlib.Algebra.Ring.Pi | ∀ (α : Type u_1) (β : Type u_2) [inst : NonUnitalNonAssocSemiring β] (x y : β),
(Pi.nonUnitalRingHom fun x => NonUnitalRingHom.id β).toFun (x * y) =
(Pi.nonUnitalRingHom fun x => NonUnitalRingHom.id β).toFun x *
(Pi.nonUnitalRingHom fun x => NonUnitalRingHom.id β).toFun y | false |
Lean.Compiler.LCNF.LetDecl.updateValue | Lean.Compiler.LCNF.CompilerM | {pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.LetDecl pu →
Lean.Compiler.LCNF.LetValue pu → Lean.Compiler.LCNF.CompilerM (Lean.Compiler.LCNF.LetDecl pu) | true |
Monotone.measure_iInter | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {ι : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : Preorder ι]
[IsCodirectedOrder ι] [Filter.atBot.IsCountablyGenerated] {s : ι → Set α},
Monotone s → (∀ (i : ι), MeasureTheory.NullMeasurableSet (s i) μ) → (∃ i, μ (s i) ≠ ⊤) → μ (⋂ i, s i) = ⨅ i, μ (s i) | true |
List.firstM._unsafe_rec | Init.Data.List.Control | {m : Type u → Type v} → [Alternative m] → {α : Type w} → {β : Type u} → (α → m β) → List α → m β | false |
AddChar.instDecidableEq | Mathlib.Algebra.Group.AddChar | {A : Type u_1} → {M : Type u_3} → [inst : AddMonoid A] → [inst_1 : Monoid M] → DecidableEq (AddChar A M) | true |
CategoryTheory.Limits.WidePushoutShape.Hom.noConfusionType | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | Sort u →
{J : Type w} →
{a a_1 : CategoryTheory.Limits.WidePushoutShape J} →
a.Hom a_1 → {J' : Type w} → {a' a'_1 : CategoryTheory.Limits.WidePushoutShape J'} → a'.Hom a'_1 → Sort u | false |
_private.Mathlib.Data.Set.Card.0.Set.ncard_congr._simp_1_2 | Mathlib.Data.Set.Card | ∀ {α : Type u_1} (s : Set α), s.ncard = Nat.card ↑s | false |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.NonCommSemiringM.0.Lean.Meta.Grind.Arith.CommRing.setTermNonCommSemiringId.match_1 | Lean.Meta.Tactic.Grind.Arith.CommRing.NonCommSemiringM | (motive : Option ℕ → Sort u_1) →
(__do_lift : Option ℕ) →
((semiringId' : ℕ) → motive (some semiringId')) → ((x : Option ℕ) → motive x) → motive __do_lift | false |
PadicInt.instCommRing._proof_26 | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)], autoParam (↑0 = 0) AddMonoidWithOne.natCast_zero._autoParam | false |
UniformContinuous₂.bicompl | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} {β : Type ub} {γ : Type uc} {δ : Type ud} {δ' : Type u_2} [inst : UniformSpace α]
[inst_1 : UniformSpace β] [inst_2 : UniformSpace γ] [inst_3 : UniformSpace δ] [inst_4 : UniformSpace δ']
{f : α → β → γ} {ga : δ → α} {gb : δ' → β},
UniformContinuous₂ f → UniformContinuous ga → UniformContinuous gb ... | true |
_private.Mathlib.Topology.Partial.0.pcontinuous_iff'._simp_1_2 | Mathlib.Topology.Partial | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {s : Set X}, (s ∈ nhds x) = ∃ t ⊆ s, IsOpen t ∧ x ∈ t | false |
CategoryTheory.pullbackShiftIso.eq_1 | Mathlib.CategoryTheory.Shift.Pullback | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u_2} {B : Type u_3} [inst_1 : AddMonoid A]
[inst_2 : AddMonoid B] (φ : A →+ B) [inst_3 : CategoryTheory.HasShift C B] (a : A) (b : B) (h : b = φ a),
CategoryTheory.pullbackShiftIso C φ a b h = CategoryTheory.eqToIso ⋯ | true |
Coalgebra.TensorProduct.lid._proof_5 | Mathlib.RingTheory.Coalgebra.TensorProduct | ∀ (R : Type u_2) (P : Type u_1) [inst : CommSemiring R] [inst_1 : AddCommMonoid P] [inst_2 : Module R P],
Function.RightInverse (TensorProduct.lid R P).invFun (↑(TensorProduct.lid R P)).toFun | false |
NNReal.sqrt_inv | Mathlib.Data.Real.Sqrt | ∀ (x : NNReal), NNReal.sqrt x⁻¹ = (NNReal.sqrt x)⁻¹ | true |
Ordinal.iSup_lt_of_lt_cof | Mathlib.SetTheory.Cardinal.Cofinality | ∀ {α : Type u} {f : α → Ordinal.{u}} {a : Ordinal.{u}}, Cardinal.mk α < a.cof → (∀ (i : α), f i < a) → ⨆ i, f i < a | true |
_private.Mathlib.Algebra.Lie.Sl2.0.IsSl2Triple.HasPrimitiveVectorWith.pow_toEnd_f_eq_zero_of_eq_nat._proof_1_4 | Mathlib.Algebra.Lie.Sl2 | (1 + 1).AtLeastTwo | false |
Std.DHashMap.Const.ofList_cons | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {k : α} {v : β} {tl : List (α × β)},
Std.DHashMap.Const.ofList ((k, v) :: tl) = Std.DHashMap.Const.insertMany (∅.insert k v) tl | true |
_private.Mathlib.Algebra.Order.Module.Defs.0.smul_eq_smul_iff_eq_and_eq_of_pos._simp_1_1 | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_2} [inst : PartialOrder α] {a b : α}, (a = b) = (a ≤ b ∧ ¬a < b) | false |
PreTilt.instCommRing._proof_17 | Mathlib.RingTheory.Perfection | ∀ (O : Type u_1) [inst : CommRing O] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : Fact ¬IsUnit ↑p] (a : PreTilt O p),
0 * a = 0 | false |
NormalizationMonoid.casesOn | Mathlib.Algebra.GCDMonoid.Basic | {α : Type u_2} →
[inst : CommMonoidWithZero α] →
{motive : NormalizationMonoid α → Sort u} →
(t : NormalizationMonoid α) →
((normUnit : α → αˣ) →
(normUnit_zero : normUnit 0 = 1) →
(normUnit_mul : ∀ {a b : α}, a ≠ 0 → b ≠ 0 → normUnit (a * b) = normUnit a * normUnit b) →
... | false |
_private.Lean.Elab.Structure.0.Lean.Elab.Command.Structure.instDecidableEqStructFieldKind.decEq._proof_13 | Lean.Elab.Structure | ∀ (structName : Lean.Name),
Lean.Elab.Command.Structure.StructFieldKind.subobject structName =
Lean.Elab.Command.Structure.StructFieldKind.newField →
False | false |
FiniteField.frobeniusAlgEquivOfAlgebraic._proof_1 | Mathlib.FieldTheory.Finite.Basic | ∀ (K : Type u_1) [inst : Field K], IsDomain K | false |
_private.Mathlib.Algebra.Free.0.FreeAddMagma.liftAux.match_1.eq_2 | Mathlib.Algebra.Free | ∀ {α : Type u_1} (motive : FreeAddMagma α → Sort u_2) (x y : FreeAddMagma α)
(h_1 : (x : α) → motive (FreeAddMagma.of x)) (h_2 : (x y : FreeAddMagma α) → motive (x.add y)),
(match x.add y with
| FreeAddMagma.of x => h_1 x
| x.add y => h_2 x y) =
h_2 x y | true |
MulChar.exists_apply_ne_one_of_hasEnoughRootsOfUnity | Mathlib.NumberTheory.MulChar.Duality | ∀ (M : Type u_1) (R : Type u_2) [inst : CommMonoid M] [inst_1 : CommRing R] [Finite M]
[HasEnoughRootsOfUnity R (Monoid.exponent Mˣ)] [Nontrivial R] {a : M}, a ≠ 1 → ∃ χ, χ a ≠ 1 | true |
Filter.addCommMonoid | Mathlib.Order.Filter.Pointwise | {α : Type u_2} → [AddCommMonoid α] → AddCommMonoid (Filter α) | true |
Lean.Parser.ParserCacheEntry.mk.inj | Lean.Parser.Types | ∀ {stx : Lean.Syntax} {lhsPrec : ℕ} {newPos : String.Pos.Raw} {errorMsg : Option Lean.Parser.Error}
{stx_1 : Lean.Syntax} {lhsPrec_1 : ℕ} {newPos_1 : String.Pos.Raw} {errorMsg_1 : Option Lean.Parser.Error},
{ stx := stx, lhsPrec := lhsPrec, newPos := newPos, errorMsg := errorMsg } =
{ stx := stx_1, lhsPrec :=... | true |
Lean.Elab.Tactic.linter.tactic.unusedName | Lean.Elab.Tactic.Lets | Lean.Option Bool | true |
Lean.Server.Test.Runner.Client.instToJsonHighlightedMsgEmbed | Lean.Server.Test.Runner | Lean.ToJson Lean.Server.Test.Runner.Client.HighlightedMsgEmbed | true |
Finmap.toFinmap_nil | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α], [].toFinmap = ∅ | true |
_private.Mathlib.CategoryTheory.Subfunctor.Basic.0.CategoryTheory.instCompleteLatticeSubfunctor._simp_7 | Mathlib.CategoryTheory.Subfunctor.Basic | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | false |
Nat.reduceSub._regBuiltin.Nat.reduceSub.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.2812229159._hygCtx._hyg.21 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | IO Unit | false |
AlgebraicGeometry.Scheme.empty._proof_1 | Mathlib.AlgebraicGeometry.Scheme | CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology ↑(TopCat.of PEmpty.{u_1 + 1}))
((CategoryTheory.Functor.const (TopologicalSpace.Opens ↑(TopCat.of PEmpty.{u_1 + 1}))ᵒᵖ).obj
(CommRingCat.of PUnit.{u_1 + 1})) | false |
Lean.instValueLeanOptionValue | Lean.Util.LeanOptions | Lean.KVMap.Value Lean.LeanOptionValue | true |
Set.iUnion_Icc_left | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type v} [inst : Preorder α] (a : α), ⋃ b, Set.Icc b a = Set.Iic a | true |
IsChain.image_relEmbedding_iff | Mathlib.Order.Preorder.Chain | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {r' : β → β → Prop} {s : Set α} {φ : r ↪r r'},
IsChain r' (⇑φ '' s) ↔ IsChain r s | true |
CategoryTheory.MorphismProperty.shiftLocalizerMorphism | Mathlib.CategoryTheory.Shift.Localization | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(W : CategoryTheory.MorphismProperty C) →
{A : Type w} →
[inst_1 : AddMonoid A] →
[inst_2 : CategoryTheory.HasShift C A] →
[W.IsCompatibleWithShift A] → A → CategoryTheory.LocalizerMorphism W W | true |
groupCohomologyIsoExt | Mathlib.RepresentationTheory.Homological.GroupCohomology.Basic | {k G : Type u} →
[inst : CommRing k] →
[inst_1 : Group G] →
(A : Rep.{u, u, u} k G) →
(n : ℕ) → groupCohomology A n ≅ ((Ext k (Rep.{u, u, u} k G) n).obj (Opposite.op (Rep.trivial k G k))).obj A | true |
_private.Mathlib.GroupTheory.OrderOfElement.0.mem_zpowers_zpow_iff._simp_1_1 | Mathlib.GroupTheory.OrderOfElement | ∀ {n : ℕ}, (n = 1) = (n ∣ 1) | false |
SSet.stdSimplex.objMk₁._proof_5 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplexOne | ∀ {n : ℕ} (i : Fin (n + 2)) (j₁ j₂ : Fin ((Opposite.unop (Opposite.op (SimplexCategory.mk n))).len + 1)),
j₁ ≤ j₂ → (fun j => if j.castSucc < i then 0 else 1) j₁ ≤ (fun j => if j.castSucc < i then 0 else 1) j₂ | false |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.Mk₁.map_id.match_1_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ (motive : Fin 2 → Prop) (i : Fin 2), (∀ (a : Unit), motive 0) → (∀ (a : Unit), motive 1) → motive i | false |
Aesop.Frontend.Parser.featIdent | Aesop.Frontend.RuleExpr | Lean.ParserDescr | true |
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.UniformOnFun.isUniformInducing_pi_restrict._simp_1_2 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} {uγ : UniformSpace γ} {f : α → β} {g : β → γ},
UniformSpace.comap f (UniformSpace.comap g uγ) = UniformSpace.comap (g ∘ f) uγ | false |
Filter.Frequently.mp | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
(∃ᶠ (x : α) in f, p x) → (∀ᶠ (x : α) in f, p x → q x) → ∃ᶠ (x : α) in f, q x | true |
CategoryTheory.CatEnrichedOrdinary.Hom.ext | Mathlib.CategoryTheory.Bicategory.CatEnriched | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.EnrichedOrdinaryCategory CategoryTheory.Cat C] {X Y : CategoryTheory.CatEnrichedOrdinary C}
{f g : X ⟶ Y} (α β : f ⟶ g),
CategoryTheory.CatEnrichedOrdinary.Hom.base α = CategoryTheory.CatEnrichedOrdinary.Hom.base β → α = β | true |
CoeT.rec | Init.Coe | {α : Sort u} →
{x : α} →
{β : Sort v} → {motive : CoeT α x β → Sort u_1} → ((coe : β) → motive { coe := coe }) → (t : CoeT α x β) → motive t | false |
_private.Mathlib.Order.UpperLower.Basic.0.IsUpperSet.top_mem.match_1_1 | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} {s : Set α} (motive : s.Nonempty → Prop) (x : s.Nonempty),
(∀ (_a : α) (ha : _a ∈ s), motive ⋯) → motive x | false |
LieAlgebra.zeroRootSubalgebra_eq_iff_is_cartan | Mathlib.Algebra.Lie.Weights.Cartan | ∀ (R : Type u_1) (L : Type u_2) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(H : LieSubalgebra R L) [inst_3 : LieRing.IsNilpotent ↥H] [IsNoetherian R L],
LieAlgebra.zeroRootSubalgebra R L H = H ↔ H.IsCartanSubalgebra | true |
CategoryTheory.Limits.ChosenPullback.LiftStruct.mk.inj | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {X₁ X₂ S : C} {f₁ : X₁ ⟶ S} {f₂ : X₂ ⟶ S}
{h : CategoryTheory.Limits.ChosenPullback f₁ f₂} {Y : C} {g₁ : Y ⟶ X₁} {g₂ : Y ⟶ X₂} {b : Y ⟶ S} {f : Y ⟶ h.pullback}
{f_p₁ :
autoParam (CategoryTheory.CategoryStruct.comp f h.p₁ = g₁)
CategoryTheory.Limits.... | true |
PointedCone.mem_dual | Mathlib.Geometry.Convex.Cone.Dual | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R] {M : Type u_2}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] {N : Type u_3} [inst_5 : AddCommMonoid N] [inst_6 : Module R N]
{p : M →ₗ[R] N →ₗ[R] R} {s : Set M} {y : N}, y ∈ PointedCone.dual p s ↔ ∀ ⦃x : M⦄, x ∈ s → 0 ≤... | true |
_private.Mathlib.LinearAlgebra.Eigenspace.Basic.0.Module.End.mapsTo_restrict_maxGenEigenspace_restrict_of_mapsTo._simp_1_1 | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | false |
CategoryTheory.ShortComplex.leftHomologyMapIso._proof_2 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {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₂) [inst_2 : S₁.HasLeftHomology] [inst_3 : S₂.HasLeftHomology],
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.leftHomologyMap e.inv)... | false |
Aesop.preTraverseUp | Aesop.Tree.Traversal | {m : Type → Type} →
[Monad m] →
[MonadLiftT (ST IO.RealWorld) m] →
(Aesop.GoalRef → m Bool) → (Aesop.RappRef → m Bool) → (Aesop.MVarClusterRef → m Bool) → Aesop.TreeRef → m Unit | true |
Array._aux_Init_Data_Array_Mem___macroRules_tacticDecreasing_trivial_2 | Init.Data.Array.Mem | Lean.Macro | false |
PUnit.instCompleteLinearOrder._proof_3 | Mathlib.Order.CompleteLattice.Lemmas | ∀ (a b c : PUnit.{u_1 + 1}), a \ b ≤ c ↔ a ≤ max b c | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point.0.tacticC_simp | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | Lean.ParserDescr | true |
WithConv.toConv_ofConv | Mathlib.Algebra.WithConv | ∀ {A : Type u_2} (x : WithConv A), WithConv.toConv x.ofConv = x | true |
Metric.unitBall.instSemigroup._proof_3 | Mathlib.Analysis.Normed.Field.UnitBall | ∀ {𝕜 : Type u_1} [inst : NonUnitalSeminormedRing 𝕜] (a b c : ↑(Metric.ball 0 1)), a * b * c = a * (b * c) | false |
Lean.Meta.Grind.CasesEntry.casesOn | Lean.Meta.Tactic.Grind.Cases | {motive : Lean.Meta.Grind.CasesEntry → Sort u} →
(t : Lean.Meta.Grind.CasesEntry) →
((declName : Lean.Name) → (eager : Bool) → motive { declName := declName, eager := eager }) → motive t | false |
CategoryTheory.Limits.CategoricalPullback.mkIso._proof_5 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u_3} {B : Type u_6} {C : Type u_4} [inst : CategoryTheory.Category.{u_1, u_3} A]
[inst_1 : CategoryTheory.Category.{u_5, u_6} B] [inst_2 : CategoryTheory.Category.{u_2, u_4} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
{x y : CategoryTheory.Limits.CategoricalPullback F G} (eₗ :... | false |
Field.sepDegree | Mathlib.FieldTheory.SeparableClosure | (F : Type u) → (E : Type v) → [inst : Field F] → [inst_1 : Field E] → [Algebra F E] → Cardinal.{v} | true |
HasProdUniformly.multipliableUniformly | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] {f : ι → β → α} {g : β → α}
[inst_1 : UniformSpace α], HasProdUniformly f g → MultipliableUniformly f | true |
Associates.instCommMonoid._proof_5 | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoid M] (a : M), ⟦a * 1⟧ = ⟦a⟧ | false |
CategoryTheory.Over.monObjMkPullbackSnd_mul | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
{X R S : C} {f : R ⟶ X} {g : S ⟶ X} [inst_2 : CategoryTheory.MonObj (CategoryTheory.Over.mk f)],
CategoryTheory.MonObj.mul =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.LaxMonoidal... | true |
Real.eq_one_of_pos_of_log_eq_zero | Mathlib.Analysis.SpecialFunctions.Log.Basic | ∀ {x : ℝ}, 0 < x → Real.log x = 0 → x = 1 | true |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.cmpEq.lt_congr_left.match_1_1 | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} {cmp : α → α → Ordering} {x z : α} (motive : Batteries.RBNode.cmpLT cmp x z → Prop)
(x_1 : Batteries.RBNode.cmpLT cmp x z), (∀ (h : ∀ [Std.TransCmp cmp], cmp x z = Ordering.lt), motive ⋯) → motive x_1 | false |
CategoryTheory.Limits.biprod.add_eq_lift_id_desc | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C} (f g : X ⟶ Y)
[inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X X],
f + g =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.biprod.lift (CategoryTheory.CategoryStruct.id X) (CategoryTheo... | true |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Counting.0.SimpleGraph.triple_eq_triple_of_mem._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Triangle.Counting | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ | false |
MeasureTheory.measure_lt_top_of_isCompact_of_isAddLeftInvariant' | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : TopologicalSpace G] [BorelSpace G] {μ : MeasureTheory.Measure G}
[inst_3 : AddGroup G] [IsTopologicalAddGroup G] [μ.IsAddLeftInvariant] {U : Set G},
(interior U).Nonempty → μ U ≠ ⊤ → ∀ {K : Set G}, IsCompact K → μ K < ⊤ | true |
_private.Mathlib.Analysis.Complex.Conformal.0.isConformalMap_complex_linear._simp_1_6 | Mathlib.Analysis.Complex.Conformal | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | false |
Polynomial.trailingDegree_eq_zero._simp_1 | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, (p.trailingDegree = 0) = (p.coeff 0 ≠ 0) | false |
groupCohomology.mapShortComplex₁_exact | Mathlib.RepresentationTheory.Homological.GroupCohomology.LongExactSequence | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {X : CategoryTheory.ShortComplex (Rep.{u, u, u} k G)}
(hX : X.ShortExact) {i j : ℕ} (hij : i + 1 = j), (groupCohomology.mapShortComplex₁ hX hij).Exact | true |
TopCat.isColimitCoconeOfForget | Mathlib.Topology.Category.TopCat.Limits.Basic | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
{F : CategoryTheory.Functor J TopCat} →
(c : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.forget TopCat))) →
CategoryTheory.Limits.IsColimit c → CategoryTheory.Limits.IsColimit (TopCat.coconeOfCoconeForget c) | true |
SlashInvariantForm.coe_const | Mathlib.NumberTheory.ModularForms.SlashInvariantForms | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} [inst : Γ.HasDetOne] (x : ℂ),
⇑(SlashInvariantForm.const x) = Function.const UpperHalfPlane x | true |
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.neg.inj | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ {c c_1 : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr},
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.neg c = Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.neg c_1 → c = c_1 | true |
Std.Time.TimeZone.TZif.TZifV2.mk.noConfusion | Std.Time.Zoned.Database.TzIf | {P : Sort u} →
{toTZifV1 : Std.Time.TimeZone.TZif.TZifV1} →
{footer : Option String} →
{toTZifV1' : Std.Time.TimeZone.TZif.TZifV1} →
{footer' : Option String} →
{ toTZifV1 := toTZifV1, footer := footer } = { toTZifV1 := toTZifV1', footer := footer' } →
(toTZifV1 = toTZifV1' → f... | false |
FormalMultilinearSeries.rightInv._proof_14 | Mathlib.Analysis.Analytic.Inverse | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E], ContinuousConstSMul 𝕜 E | false |
CategoryTheory.Functor.instLaxMonoidalActionMapAction._proof_2 | Mathlib.CategoryTheory.Action.Monoidal | ∀ {V : Type u_5} [inst : CategoryTheory.Category.{u_4, u_5} V] {G : Type u_2} [inst_1 : Monoid G] {W : Type u_3}
[inst_2 : CategoryTheory.Category.{u_1, u_3} W] [inst_3 : CategoryTheory.MonoidalCategory V]
[inst_4 : CategoryTheory.MonoidalCategory W] (F : CategoryTheory.Functor V W) [inst_5 : F.LaxMonoidal]
{X Y ... | false |
ValuationRing.mk._flat_ctor | Mathlib.RingTheory.Valuation.ValuationRing | ∀ {A : Type u} [inst : CommRing A] [inst_1 : IsDomain A], (∀ (a b : A), ∃ c, a * c = b ∨ b * c = a) → ValuationRing A | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.nodup_insertRatUnits._proof_1_6 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult | ∀ {n : ℕ} (f : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n)
(units : Std.Sat.CNF.Clause (Std.Tactic.BVDecide.LRAT.Internal.PosFin n))
(w : Fin (f.insertRatUnits units).1.ratUnits.size),
↑w + 1 ≤ (f.insertRatUnits units).1.ratUnits.size → ↑w < (f.insertRatUnits units).1.ratUnits.size | false |
Lean.Lsp.instOrdPosition | Lean.Data.Lsp.BasicAux | Ord Lean.Lsp.Position | true |
MeasureTheory.condExpL2_comp_continuousLinearMap | 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'] [inst_4 : NormedSpace ℝ E'] {m m0 : MeasurableSpace α}
{μ : MeasureTheory.Measure α} {E'' : Type u_8} (𝕜' : Type u_9) [inst_5 : RCLike 𝕜'] [inst_6 : N... | true |
Int.one_ne_zero | Init.Data.Int.Order | 1 ≠ 0 | true |
CategoryTheory.MorphismProperty.ofHoms_iff | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {ι : Type u_2} {X Y : ι → C} (f : (i : ι) → X i ⟶ Y i)
{A B : C} (g : A ⟶ B),
CategoryTheory.MorphismProperty.ofHoms f g ↔ ∃ i, CategoryTheory.Arrow.mk g = CategoryTheory.Arrow.mk (f i) | true |
_private.Aesop.Search.ExpandSafePrefix.0.Aesop.isSafeExpansionFailedException.match_1 | Aesop.Search.ExpandSafePrefix | (motive : Lean.Exception → Sort u_1) →
(x : Lean.Exception) →
((id : Lean.InternalExceptionId) → (extra : Lean.KVMap) → motive (Lean.Exception.internal id extra)) →
((x : Lean.Exception) → motive x) → motive x | false |
Fin.attachFin_Ioo | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (a b : Fin n), (Finset.Ioo ↑a ↑b).attachFin ⋯ = Finset.Ioo a b | true |
Submodule.LinearDisjoint.one_left | Mathlib.LinearAlgebra.LinearDisjoint | ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] (N : Submodule R S),
Submodule.LinearDisjoint 1 N | true |
LinearMap.toSpanSingleton | Mathlib.LinearAlgebra.Span.Basic | (R : Type u_1) →
(M : Type u_4) → [inst : Semiring R] → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → M → R →ₗ[R] M | true |
_private.Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities.0.MvPolynomial.NewtonIdentities.weight_add_weight_pairMap | Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities | ∀ (σ : Type u_1) (R : Type u_2) [inst : CommRing R] [inst_1 : DecidableEq σ] [inst_2 : Fintype σ] {k : ℕ},
∀ t ∈ MvPolynomial.NewtonIdentities.pairs✝ σ k,
MvPolynomial.NewtonIdentities.weight✝ σ R k t +
MvPolynomial.NewtonIdentities.weight✝¹ σ R k (MvPolynomial.NewtonIdentities.pairMap✝ σ t) =
0 | true |
_private.Mathlib.AlgebraicTopology.SimplicialObject.ChainHomotopy.0.CategoryTheory.SimplicialObject.Homotopy.ToChainHomotopy.comm_succ._proof_1_28 | Mathlib.AlgebraicTopology.SimplicialObject.ChainHomotopy | ∀ (n j : ℕ), j < n + 1 → j.succ < (n + 1).succ | false |
Aesop.RuleResult._sizeOf_1 | Aesop.Search.Expansion | Aesop.RuleResult → ℕ | false |
List.map_injective_iff._simp_1 | Mathlib.Data.List.Basic | ∀ {α : Type u} {β : Type v} {f : α → β}, Function.Injective (List.map f) = Function.Injective f | false |
Finsupp.instZero._proof_1 | Mathlib.Data.Finsupp.Defs | ∀ {α : Type u_1} {M : Type u_2} [inst : Zero M] (x : α), x ∈ ∅ ↔ 0 x ≠ 0 | false |
continuousSubring._proof_5 | Mathlib.Topology.ContinuousMap.Algebra | ∀ (α : Type u_1) (R : Type u_2) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace R] [inst_2 : Ring R]
[inst_3 : IsTopologicalRing R] {a b : α → R},
a ∈ (continuousAddSubgroup α R).carrier →
b ∈ (continuousAddSubgroup α R).carrier → a + b ∈ (continuousAddSubgroup α R).carrier | false |
FundamentalGroupoid.termπₘ | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | Lean.ParserDescr | true |
Lean.Parser.checkSimpFailure | Init.Notation | Lean.ParserDescr | true |
Lean.Server.Test.Runner.Client.MsgEmbed._sizeOf_4_eq | Lean.Server.Test.Runner | ∀ (x : Array (Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed)),
Lean.Server.Test.Runner.Client.MsgEmbed._sizeOf_4 x = sizeOf x | false |
Metric.unitSphere.coe_pow | Mathlib.Analysis.Normed.Field.UnitBall | ∀ {𝕜 : Type u_1} [inst : SeminormedRing 𝕜] [inst_1 : NormMulClass 𝕜] [inst_2 : NormOneClass 𝕜]
(x : ↑(Metric.sphere 0 1)) (n : ℕ), ↑(x ^ n) = ↑x ^ n | true |
SimpleGraph.deleteIncidenceSet | Mathlib.Combinatorics.SimpleGraph.DeleteEdges | {V : Type u_1} → SimpleGraph V → V → SimpleGraph V | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.