name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Sum.map_injective | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {f : α → γ} {g : β → δ},
Function.Injective (Sum.map f g) ↔ Function.Injective f ∧ Function.Injective g | true |
CochainComplex.isZero_of_isLE._auto_1 | Mathlib.Algebra.Homology.Embedding.CochainComplex | Lean.Syntax | false |
Std.ExtDHashMap.mem_iff_isSome_getKey? | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {a : α}, a ∈ m ↔ (m.getKey? a).isSome = true | true |
Lean.Elab.Term.Quotation.initFn._@.Lean.Elab.Quotation.Precheck.4121763900._hygCtx._hyg.2 | Lean.Elab.Quotation.Precheck | IO (Lean.KeyedDeclsAttribute Lean.Elab.Term.Quotation.Precheck) | false |
Function.HasFiniteMulSupport.fun_pow | Mathlib.Algebra.FiniteSupport.Basic | ∀ {α : Type u_1} {M : Type u_3} [inst : Monoid M] {f : α → M},
Function.HasFiniteMulSupport f → ∀ (n : ℕ), Function.HasFiniteMulSupport fun i => f i ^ n | true |
Subgroup.finiteIndex_ker | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : Group G] {G' : Type u_3} [inst_1 : Group G'] (f : G →* G') [Finite ↥f.range], f.ker.FiniteIndex | true |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.mkBelowMatcher.match_5 | Lean.Meta.IndPredBelow | (motive : ℕ → Bool → ℕ → Sort u_1) →
(oldCount : ℕ) →
(hasEqns : Bool) →
(x : ℕ) →
((n : ℕ) → motive 0 false n.succ) →
((x : ℕ) → (x_1 : Bool) → (x_2 : ℕ) → motive x x_1 x_2) → motive oldCount hasEqns x | false |
CategoryTheory.Bimon.equivMonComonCounitIsoApp_hom_hom_hom | Mathlib.CategoryTheory.Monoidal.Bimon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (M : CategoryTheory.Mon (CategoryTheory.Comon C)),
(CategoryTheory.Bimon.equivMonComonCounitIsoApp M).hom.hom.hom = CategoryTheory.CategoryStruct.id M.X.X | true |
minpoly.IsIntegrallyClosed.isIntegral_iff_isUnit_leadingCoeff | Mathlib.FieldTheory.Minpoly.IsIntegrallyClosed | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [IsDomain R] [inst_3 : Algebra R S]
[IsIntegrallyClosed R] [IsDomain S] [Module.IsTorsionFree R S] {x : S} {p : Polynomial R},
Irreducible p → (Polynomial.aeval x) p = 0 → (IsIntegral R x ↔ IsUnit p.leadingCoeff) | true |
Std.HashMap.Raw.insertMany | Std.Data.HashMap.Raw | {α : Type u} →
{β : Type v} →
[BEq α] → [Hashable α] → {ρ : Type w} → [ForIn Id ρ (α × β)] → Std.HashMap.Raw α β → ρ → Std.HashMap.Raw α β | true |
_private.Mathlib.Analysis.SpecialFunctions.Gamma.Deligne.0.Complex.Gammaℝ_eq_zero_iff._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Gamma.Deligne | ∀ (s : ℂ), (Complex.Gamma s = 0) = ∃ m, s = -↑m | false |
Lean.Meta.SynthInstance.Context.maxHeartbeats | Lean.Meta.SynthInstance | Lean.Meta.SynthInstance.Context → ℕ | true |
HomotopicalAlgebra.FibrantObject.HoCat.localizerMorphismResolution._proof_3 | Mathlib.AlgebraicTopology.ModelCategory.FibrantObjectHomotopy | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] (x x_1 : C)
(x_2 : x ⟶ x_1),
HomotopicalAlgebra.weakEquivalences C x_2 →
(HomotopicalAlgebra.weakEquivalences (HomotopicalAlgebra.FibrantObject.HoCat C)).inverseImage
HomotopicalAlgebra.FibrantObje... | false |
_private.Mathlib.Topology.Connected.LocPathConnected.0.locPathConnectedSpace_iff_isOpen_pathComponentIn.match_1_1 | Mathlib.Topology.Connected.LocPathConnected | ∀ {X : Type u_1} [inst : TopologicalSpace X] (x : X) (s : Set X)
(motive : (∃ i, (i ∈ nhds x ∧ IsPathConnected i) ∧ id i ⊆ s) → Prop)
(x_1 : ∃ i, (i ∈ nhds x ∧ IsPathConnected i) ∧ id i ⊆ s),
(∀ (w : Set X) (ht : (w ∈ nhds x ∧ IsPathConnected w) ∧ id w ⊆ s), motive ⋯) → motive x_1 | false |
BoundedContinuousFunction.instMonoid._proof_2 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u_1} {R : Type u_2} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace R] [inst_2 : Monoid R]
[inst_3 : BoundedMul R] [inst_4 : ContinuousMul R] (a : BoundedContinuousFunction α R), 1 * a = a | false |
instDecidableEqNzsNum.decEq._sunfold | Mathlib.Data.Num.Bitwise | (x x_1 : NzsNum) → Decidable (x = x_1) | false |
Algebra.intNormAux._proof_1 | Mathlib.RingTheory.IntegralClosure.IntegralRestrict | ∀ (A : Type u_1) (K : Type u_2) (L : Type u_3) (B : Type u_4) [inst : CommRing A] [inst_1 : CommRing B]
[inst_2 : Algebra A B] [inst_3 : Field K] [inst_4 : Field L] [inst_5 : Algebra A K] [inst_6 : IsFractionRing A K]
[inst_7 : Algebra K L] [inst_8 : Algebra A L] [inst_9 : IsScalarTower A K L] [inst_10 : Algebra B ... | false |
Int64.or_eq_zero_iff._simp_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int64}, (a ||| b = 0) = (a = 0 ∧ b = 0) | false |
Mathlib.Tactic.FieldSimp.DenomCondition.proof | Mathlib.Tactic.FieldSimp | {v : Lean.Level} →
{M : Q(Type v)} →
{iM : Q(GroupWithZero «$M»)} → Mathlib.Tactic.FieldSimp.qNF M → Mathlib.Tactic.FieldSimp.DenomCondition iM → Type | true |
_private.Mathlib.NumberTheory.PellMatiyasevic.0.Pell.eq_of_xn_modEq.match_1_1 | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a i j n : ℕ} (motive : a = 2 ∧ n = 1 ∧ i = 0 ∧ j = 2 → Prop) (x : a = 2 ∧ n = 1 ∧ i = 0 ∧ j = 2),
(∀ (a2 : a = 2) (n1 : n = 1) (i0 : i = 0) (j2 : j = 2), motive ⋯) → motive x | false |
_private.Std.Data.ExtHashMap.Lemmas.0.Std.ExtHashMap.alter_eq_empty_iff._simp_1_1 | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m m' : Std.ExtHashMap α β}, (m = m') = (m.inner = m'.inner) | false |
_private.Lean.Elab.Tactic.Grind.SimprocDSLBuiltin.0.Lean.Elab.Tactic.Grind.elabOptDischarger.match_1 | Lean.Elab.Tactic.Grind.SimprocDSLBuiltin | (motive : Option (Lean.TSyntax `sym_discharger) → Sort u_1) →
(discharger? : Option (Lean.TSyntax `sym_discharger)) →
((discharger : Lean.TSyntax `sym_discharger) → motive (some discharger)) →
((x : Option (Lean.TSyntax `sym_discharger)) → motive x) → motive discharger? | false |
FixedPoints.subsemiring._proof_3 | Mathlib.Algebra.Algebra.Subalgebra.Operations | ∀ (B' : Type u_1) [inst : Semiring B'] (G : Type u_2) [inst_1 : Monoid G] [inst_2 : MulSemiringAction G B'] {a b : B'},
a ∈ (FixedPoints.addSubmonoid G B').carrier →
b ∈ (FixedPoints.addSubmonoid G B').carrier → a + b ∈ (FixedPoints.addSubmonoid G B').carrier | false |
_private.Init.Data.UInt.Bitwise.0.UInt16.not_ne_self._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt16}, (a = b) = (a.toBitVec = b.toBitVec) | false |
Std.HashSet.forall_mem_toArray_iff_forall_mem_get | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {p : α → Prop},
(∀ k ∈ m.toArray, p k) ↔ ∀ (k : α) (h : k ∈ m), p (m.get k h) | true |
Polynomial.SplittingField.instGroupWithZero._proof_2 | Mathlib.FieldTheory.SplittingField.Construction | ∀ {K : Type u_1} [inst : Field K] (f : Polynomial K) (a : f.SplittingField), zpowRec npowRec 0 a = 1 | false |
ProofWidgets.RpcEncodablePacket.done.sizeOf_spec._@.ProofWidgets.Cancellable.1202226121._hygCtx._hyg.1 | ProofWidgets.Cancellable | ∀ (result : Lean.Json), sizeOf (ProofWidgets.RpcEncodablePacket.done✝ result) = 1 + sizeOf result | false |
WeierstrassCurve.isCharNeTwoNF_of_isShortNF | Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms | ∀ {R : Type u_1} [inst : CommRing R] (W : WeierstrassCurve R) [W.IsShortNF], W.IsCharNeTwoNF | true |
Polynomial.degree_C_mul_X | Mathlib.Algebra.Polynomial.Degree.Defs | ∀ {R : Type u} {a : R} [inst : Semiring R], a ≠ 0 → (Polynomial.C a * Polynomial.X).degree = 1 | true |
aestronglyMeasurable_const_smul_iff₀ | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f : α → β} {G₀ : Type u_7} [inst_1 : GroupWithZero G₀] [inst_2 : MulAction G₀ β] [ContinuousConstSMul G₀ β] {c : G₀},
c ≠ 0 → (MeasureTheory.AEStronglyMeasurable (fun x => c • f x) μ ↔ MeasureTheory.A... | true |
Lean.Meta.MVarRenaming.rec | Lean.Meta.Match.MVarRenaming | {motive : Lean.Meta.MVarRenaming → Sort u} →
((map : Lean.MVarIdMap Lean.MVarId) → motive { map := map }) → (t : Lean.Meta.MVarRenaming) → motive t | false |
Ultrafilter.comap_inf_principal_neBot_of_image_mem | Mathlib.Order.Filter.Ultrafilter.Defs | ∀ {α : Type u} {β : Type v} {m : α → β} {s : Set α} {g : Ultrafilter β},
m '' s ∈ g → (Filter.comap m ↑g ⊓ Filter.principal s).NeBot | true |
CategoryTheory.Limits.prodComparison_snd_assoc | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{w, u₂} D]
(F : CategoryTheory.Functor C D) (A B : C) [inst_2 : CategoryTheory.Limits.HasBinaryProduct A B]
[inst_3 : CategoryTheory.Limits.HasBinaryProduct (F.obj A) (F.obj B)] {Z : D} (h : F.obj B ⟶ Z),
Cate... | true |
_private.Mathlib.Topology.Category.CompHausLike.SigmaComparison.0.CompHausLike.sigmaComparison_eq_comp_isos._simp_1_4 | Mathlib.Topology.Category.CompHausLike.SigmaComparison | ∀ {C : Type u₁} [inst : CategoryTheory.CategoryStruct.{v₁, u₁} C] {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp g.unop f.unop = (CategoryTheory.CategoryStruct.comp f g).unop | false |
IsScalarTower.algebraMap_smul | Mathlib.Algebra.Algebra.Tower | ∀ {R : Type u} (A : Type w) {M : Type v₁} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : MulAction A M] [inst_4 : SMul R M] [IsScalarTower R A M] (r : R) (x : M), (algebraMap R A) r • x = r • x | true |
Fin.map_revPerm_uIcc | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (i j : Fin n), Finset.map (Equiv.toEmbedding Fin.revPerm) (Finset.uIcc i j) = Finset.uIcc i.rev j.rev | true |
PrimeSpectrum.mapPiLocalization_bijective | Mathlib.RingTheory.Spectrum.Maximal.Localization | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] (f : R →+* S),
Function.Bijective ⇑f → Function.Bijective ⇑(PrimeSpectrum.mapPiLocalization f) | true |
measurable_natCast | Mathlib.MeasureTheory.MeasurableSpace.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] [inst_2 : NatCast α] (n : ℕ),
Measurable ↑n | true |
_private.Mathlib.Analysis.Convex.Gauge.0.gauge_smul_of_nonneg._simp_1_3 | Mathlib.Analysis.Convex.Gauge | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Ioi b) = (b < x) | false |
Quiver.HasReverse.ctorIdx | Mathlib.Combinatorics.Quiver.Symmetric | {V : Type u_2} → {inst : Quiver V} → Quiver.HasReverse V → ℕ | false |
_private.Mathlib.Lean.Expr.Basic.0.Lean.Expr.getAppAppsAux._sunfold | Mathlib.Lean.Expr.Basic | Lean.Expr → Array Lean.Expr → ℕ → Array Lean.Expr | false |
Lean.Linter.List.allowedListNames | Lean.Linter.List | List String | true |
Mathlib.Meta.NormNum.IsNat.recOn | Mathlib.Tactic.NormNum.Result | {α : Type u} →
[inst : AddMonoidWithOne α] →
{a : α} →
{n : ℕ} →
{motive : Mathlib.Meta.NormNum.IsNat a n → Sort u_1} →
(t : Mathlib.Meta.NormNum.IsNat a n) → ((out : a = ↑n) → motive ⋯) → motive t | false |
NormedAddGroupHom.coe_sub | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
(f g : NormedAddGroupHom V₁ V₂), ⇑(f - g) = ⇑f - ⇑g | true |
Finset.Nat.sigmaAntidiagonalTupleEquivTuple._proof_2 | Mathlib.Data.Fin.Tuple.NatAntidiagonal | ∀ (k : ℕ) (x : (n : ℕ) × ↥(Finset.Nat.antidiagonalTuple k n)), ↑x.snd ∈ Finset.Nat.antidiagonalTuple k (∑ i, ↑x.snd i) | false |
cross_self | Mathlib.LinearAlgebra.CrossProduct | ∀ {R : Type u_1} [inst : CommRing R] (v : Fin 3 → R), (crossProduct v) v = 0 | true |
Rat.add_le_add_right | Init.Data.Rat.Lemmas | ∀ {a b c : ℚ}, a + c ≤ b + c ↔ a ≤ b | true |
mulRightStrictMono_of_mulRightReflectLE | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | ∀ (N : Type u_2) [inst : Mul N] [inst_1 : LinearOrder N] [MulRightReflectLE N], MulRightStrictMono N | true |
Lean.ParserCompiler.CombinatorAttribute.getDeclFor? | Lean.ParserCompiler.Attribute | Lean.ParserCompiler.CombinatorAttribute → Lean.Environment → Lean.Name → Option Lean.Name | true |
CategoryTheory.Monad.Algebra.isoMk._proof_2 | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T : CategoryTheory.Monad C} {A B : T.Algebra}
(h : A.A ≅ B.A),
CategoryTheory.CategoryStruct.comp (T.map h.hom) B.a = CategoryTheory.CategoryStruct.comp A.a h.hom →
CategoryTheory.CategoryStruct.comp (T.map h.hom) B.a = CategoryTheory.CategoryStruc... | false |
Lean.insertUnexpander | Init.NotationExtra | Lean.PrettyPrinter.Unexpander | true |
OpenPartialHomeomorph.univUnitBall._proof_12 | Mathlib.Analysis.Normed.Module.Ball.Homeomorph | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E],
ContinuousOn (fun y => (√(1 - ‖y‖ ^ 2))⁻¹ • y) (Metric.ball 0 1) | false |
CategoryTheory.PreGaloisCategory.instMulActionAutObjFiniteVFintypeCatFunctorObjActionFunctorToAction._proof_3 | Mathlib.CategoryTheory.Galois.Action | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (F : CategoryTheory.Functor C FintypeCat) (X : C)
(x y : CategoryTheory.Aut X) (b : ((CategoryTheory.PreGaloisCategory.functorToAction F).obj X).V.obj),
(x * y) • b = x • y • b | false |
_private.Mathlib.Analysis.InnerProductSpace.Rayleigh.0.ContinuousLinearMap.spectralRadius_eq_nnnorm._proof_1_2 | Mathlib.Analysis.InnerProductSpace.Rayleigh | ∀ {E : Type u_1} [inst_1 : NormedAddCommGroup E], IsTopologicalAddGroup E | false |
CategoryTheory.MorphismProperty.IsStableUnderTransfiniteComposition.instIsMultiplicative | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C)
[W.IsStableUnderTransfiniteComposition], W.IsMultiplicative | true |
WithVal.noConfusion | Mathlib.Topology.Algebra.Valued.WithVal | {P : Sort u} →
{R : Type u_1} →
{Γ₀ : Type u_2} →
{inst : LinearOrderedCommGroupWithZero Γ₀} →
{inst_1 : Ring R} →
{v : Valuation R Γ₀} →
{t : WithVal v} →
{R' : Type u_1} →
{Γ₀' : Type u_2} →
{inst' : LinearOrderedCommGroupWithZe... | false |
isGLB_pair | Mathlib.Order.Bounds.Basic | ∀ {γ : Type u_3} [inst : SemilatticeInf γ] {a b : γ}, IsGLB {a, b} (a ⊓ b) | true |
BooleanSubalgebra.val_inf._simp_1 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} [inst : BooleanAlgebra α] {L : BooleanSubalgebra α} (a b : ↥L), ↑a ⊓ ↑b = ↑(a ⊓ b) | false |
Homeomorph.piFinTwo | Mathlib.Topology.Homeomorph.Lemmas | (X : Fin 2 → Type u) → [inst : (i : Fin 2) → TopologicalSpace (X i)] → ((i : Fin 2) → X i) ≃ₜ X 0 × X 1 | true |
CategoryTheory.ShortComplex.FunctorEquivalence.inverse._proof_6 | Mathlib.Algebra.Homology.ShortComplex.FunctorEquivalence | ∀ (J : Type u_1) (C : Type u_3) [inst : CategoryTheory.Category.{u_4, u_1} J]
[inst_1 : CategoryTheory.Category.{u_2, u_3} C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : CategoryTheory.Functor J (CategoryTheory.ShortComplex C)} (φ : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor... | false |
Std.Internal.IO.Async.System.CPUInfo._sizeOf_1 | Std.Internal.Async.System | Std.Internal.IO.Async.System.CPUInfo → ℕ | false |
AlgebraicTopology.DoldKan.toKaroubiCompN₂IsoN₁ | Mathlib.AlgebraicTopology.DoldKan.FunctorN | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
(CategoryTheory.Idempotents.toKaroubi (CategoryTheory.SimplicialObject C)).comp AlgebraicTopology.DoldKan.N₂ ≅
AlgebraicTopology.DoldKan.N₁ | true |
Batteries.Tactic.GeneralizeProofs.AContext.fvars._default | Batteries.Tactic.GeneralizeProofs | Array Lean.Expr | false |
FreeRing.map_of | Mathlib.RingTheory.FreeRing | ∀ {α : Type u} {β : Type v} (f : α → β) (x : α), (FreeRing.map f) (FreeRing.of x) = FreeRing.of (f x) | true |
FreeRing.subsingletonEquivFreeCommRing._proof_2 | Mathlib.RingTheory.FreeCommRing | ∀ (α : Type u_1), NonUnitalRingHomClass (FreeRing α →+* FreeCommRing α) (FreeRing α) (FreeCommRing α) | false |
SubMulAction.mem_one | Mathlib.GroupTheory.GroupAction.SubMulAction.Pointwise | ∀ {R : Type u_1} {M : Type u_2} [inst : Monoid R] [inst_1 : MulAction R M] [inst_2 : One M] {x : M},
x ∈ 1 ↔ ∃ r, r • 1 = x | true |
_private.Mathlib.Data.Ordmap.Ordset.0.Ordnode.Valid'.balance'_lemma._proof_1_2 | Mathlib.Data.Ordmap.Ordset | ∀ {α : Type u_1} {l : Ordnode α}, 1 + 1 ≤ 3 * (l.size + 1) | false |
Lean.Elab.Tactic.BVDecide.LRAT.trim.Context.casesOn | Lean.Elab.Tactic.BVDecide.LRAT.Trim | {motive : Lean.Elab.Tactic.BVDecide.LRAT.trim.Context → Sort u} →
(t : Lean.Elab.Tactic.BVDecide.LRAT.trim.Context) →
((proof : Std.HashMap ℕ Std.Tactic.BVDecide.LRAT.IntAction) →
(initialId addEmptyId : ℕ) → motive { proof := proof, initialId := initialId, addEmptyId := addEmptyId }) →
motive t | false |
RootPairing.EmbeddedG2.span_eq_top | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | ∀ {ι : 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)
[inst_5 : P.EmbeddedG2] [Finite ι] [CharZero R] [IsDomain R] [P.IsIrreducible],
Submodule.span R {RootPairing.... | true |
Complex.hasStrictDerivAt_tan | Mathlib.Analysis.SpecialFunctions.Trigonometric.ComplexDeriv | ∀ {x : ℂ}, Complex.cos x ≠ 0 → HasStrictDerivAt Complex.tan (1 / Complex.cos x ^ 2) x | true |
_private.Mathlib.Data.Tree.Basic.0.Tree.traverse.match_1.splitter | Mathlib.Data.Tree.Basic | {α : Type u_1} →
(motive : Tree α → Sort u_2) →
(x : Tree α) → (Unit → motive Tree.nil) → ((a : α) → (l r : Tree α) → motive (Tree.node a l r)) → motive x | true |
GeneralizedBooleanAlgebra.toNonUnitalCommRing._proof_14 | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : GeneralizedBooleanAlgebra α] (a b : α), a ⊓ b = b ⊓ a | false |
Lean.JsonRpc.ErrorCode.parseError | Lean.Data.JsonRpc | Lean.JsonRpc.ErrorCode | true |
ReaderT.run_seqLeft | Init.Control.Lawful.Instances | ∀ {m : Type u_1 → Type u_2} {ρ α β : Type u_1} [inst : Monad m] (x : ReaderT ρ m α) (y : ReaderT ρ m β) (ctx : ρ),
(x <* y).run ctx = x.run ctx <* y.run ctx | true |
IsLocalization.Away.invSelf._proof_1 | Mathlib.RingTheory.Localization.Away.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (x : R), x ∈ Submonoid.powers x | false |
Std.Refl.refl | Init.Core | ∀ {α : Sort u} {r : α → α → Prop} [self : Std.Refl r] (a : α), r a a | true |
_private.Mathlib.Tactic.Linarith.Parsing.0.Mathlib.Tactic.Linarith.linearFormOfExpr.match_1 | Mathlib.Tactic.Linarith.Parsing | (motive : Mathlib.Tactic.Linarith.ExprMap × Mathlib.Tactic.Linarith.Sum → Sort u_1) →
(__discr : Mathlib.Tactic.Linarith.ExprMap × Mathlib.Tactic.Linarith.Sum) →
((m2 : Mathlib.Tactic.Linarith.ExprMap) → (comp2 : Mathlib.Tactic.Linarith.Sum) → motive (m2, comp2)) →
motive __discr | false |
LieAlgebra.IsKilling.rootSpace_neg_nsmul_add_chainTop_of_lt | Mathlib.Algebra.Lie.Weights.RootSystem | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : CharZero K] [inst_2 : LieRing L] [inst_3 : LieAlgebra K L]
[inst_4 : LieAlgebra.IsKilling K L] [inst_5 : FiniteDimensional K L] {H : LieSubalgebra K L}
[inst_6 : H.IsCartanSubalgebra] [inst_7 : LieModule.IsTriangularizable K (↥H) L] (α β : LieModule.Weight ... | true |
Nat.map_add_toArray_rcc' | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n k : ℕ}, Array.map (fun x => k + x) (m...=n).toArray = ((k + m)...=k + n).toArray | true |
CategoryTheory.Limits.PreservesFiniteLimitsOfIsFilteredCostructuredArrowYonedaAux.iso._proof_10 | Mathlib.CategoryTheory.Limits.Preserves.Presheaf | ∀ {C : Type u_1} [inst : CategoryTheory.SmallCategory C] (A : CategoryTheory.Functor Cᵒᵖ (Type u_1)) {J : Type}
[inst_1 : CategoryTheory.SmallCategory J] (K : CategoryTheory.Functor J Cᵒᵖ),
CategoryTheory.Limits.HasLimit
(K.comp
(CategoryTheory.coyoneda.comp
((CategoryTheory.Functor.whiskeringLeft... | false |
RingHom.rangeS_top_iff_surjective | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] {f : R →+* S},
f.rangeS = ⊤ ↔ Function.Surjective ⇑f | true |
AlgebraicGeometry.Scheme.Hom.comp_appLE | Mathlib.AlgebraicGeometry.Scheme | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) (U : Z.Opens) (V : X.Opens)
(e : V ≤ (TopologicalSpace.Opens.map (CategoryTheory.CategoryStruct.comp f g).base).obj U),
AlgebraicGeometry.Scheme.Hom.appLE (CategoryTheory.CategoryStruct.comp f g) U V e =
CategoryTheory.CategoryStruct.comp (AlgebraicGe... | true |
Lean.Meta.Grind.Arith.Cutsat.UnsatProof.diseq.injEq | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (c c_1 : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr),
(Lean.Meta.Grind.Arith.Cutsat.UnsatProof.diseq c = Lean.Meta.Grind.Arith.Cutsat.UnsatProof.diseq c_1) = (c = c_1) | true |
Function.Periodic.sub_antiperiod_eq | Mathlib.Algebra.Ring.Periodic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c₁ c₂ : α} [inst : AddGroup α] [inst_1 : InvolutiveNeg β],
Function.Periodic f c₁ → Function.Antiperiodic f c₂ → f (c₁ - c₂) = -f 0 | true |
ModularGroup.coe_T_zpow | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ (n : ℤ), ↑(ModularGroup.T ^ n) = !![1, n; 0, 1] | true |
Std.DTreeMap.Internal.Impl.size_erase! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF →
∀ {k : α},
(Std.DTreeMap.Internal.Impl.erase! k t).size =
if Std.DTreeMap.Internal.Impl.contains k t = true then t.size - 1 else t.size | true |
_private.Mathlib.Topology.Sequences.0.FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto._simp_1_3 | Mathlib.Topology.Sequences | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | false |
_private.Mathlib.Analysis.Convex.DoublyStochasticMatrix.0.doublyStochastic_eq_rowStochastic_inf_colStochastic._simp_1_2 | Mathlib.Analysis.Convex.DoublyStochasticMatrix | ∀ {M : Type u_1} [inst : MulOneClass M] {s : Subsemigroup M} {x : M} (h_one : 1 ∈ s.carrier),
(x ∈ { toSubsemigroup := s, one_mem' := h_one }) = (x ∈ s) | false |
MeasureTheory.Measure.IsAddHaarMeasure.isNegInvariant_of_innerRegular | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G]
[inst_3 : MeasurableSpace G] [BorelSpace G] (μ : MeasureTheory.Measure G) [μ.IsAddHaarMeasure] [LocallyCompactSpace G]
[μ.InnerRegular], μ.IsNegInvariant | true |
Lean.Parser.Term.clear.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | true |
MonoidWithZeroHom.inl.eq_1 | Mathlib.Algebra.GroupWithZero.ProdHom | ∀ (G₀ : Type u_1) (H₀ : Type u_2) [inst : GroupWithZero G₀] [inst_1 : GroupWithZero H₀]
[inst_2 : DecidablePred fun x => x = 0],
MonoidWithZeroHom.inl G₀ H₀ = (WithZero.map' (MonoidHom.inl G₀ˣ H₀ˣ)).comp ↑WithZero.withZeroUnitsEquiv.symm | true |
CategoryTheory.Limits.kernelSubobjectMap._proof_2 | Mathlib.CategoryTheory.Subobject.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C}
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {f : X ⟶ Y} [inst_2 : CategoryTheory.Limits.HasKernel f]
{X' Y' : C} {f' : X' ⟶ Y'} [inst_3 : CategoryTheory.Limits.HasKernel f']
(sq : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk f... | false |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.Balanced.append.match_1_21 | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} (a : Batteries.RBNode α) (x y : α) (d : Batteries.RBNode α) (n : ℕ) (bc : Batteries.RBNode α)
(motive : (∃ c, (a.balance2 x (Batteries.RBNode.node Batteries.RBColor.red bc y d)).Balanced c (n + 1)) → Prop)
(x_1 : ∃ c, (a.balance2 x (Batteries.RBNode.node Batteries.RBColor.red bc y d)).Balanced c (n... | false |
TypeVec.id | Mathlib.Data.TypeVec | {n : ℕ} → {α : TypeVec.{u_1} n} → α.Arrow α | true |
HomogeneousLocalization.NumDenSameDeg.instZero | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | {ι : Type u_1} →
{A : Type u_2} →
{σ : Type u_3} →
[inst : CommRing A] →
[inst_1 : SetLike σ A] →
[inst_2 : AddSubmonoidClass σ A] →
{𝒜 : ι → σ} →
(x : Submonoid A) →
[inst_3 : AddCommMonoid ι] →
[inst_4 : DecidableEq ι] → [Grade... | true |
Nat.largeSchroder._proof_2 | Mathlib.Combinatorics.Enumerative.Schroder | ∀ (n : ℕ) (i : Fin n.succ), InvImage (fun x1 x2 => x1 < x2) (fun x => x) (↑i) n.succ | false |
CategoryTheory.curriedCoyonedaLemma | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.SmallCategory C] →
CategoryTheory.coyoneda.rightOp.comp CategoryTheory.coyoneda ≅ CategoryTheory.evaluation C (Type u₁) | true |
CommSemiring.toNonUnitalCommSemiring._proof_3 | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u_1} [inst : CommSemiring α] (a : α), 0 * a = 0 | false |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.mul.injEq | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (a? : Option Lean.Expr) (cs : Array (Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr)) (a?_1 : Option Lean.Expr)
(cs_1 : Array (Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr)),
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.mul a? cs = Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.mul a?_1 cs_1) =
(a? = a... | true |
MeasureTheory.Measure.sub_def | Mathlib.MeasureTheory.Measure.Sub | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α}, μ - ν = sInf {d | μ ≤ d + ν} | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.