name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
OrderIso.setIsotypicComponents._proof_4 | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [IsSemisimpleModule R M]
(m : ↥(fullyInvariantSubmodule R M)) (S : Submodule R M),
IsSimpleModule R ↥S → S ≤ ↑m → isotypicComponent R M ↥S ≤ ↑(⨆ i ∈ (fun m => {c | ↑c ≤ ↑m}) m, ⟨↑i, ⋯⟩) | false |
HomologicalComplex.xNextIso | Mathlib.Algebra.Homology.HomologicalComplex | {ι : Type u_1} →
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] →
{c : ComplexShape ι} → (C : HomologicalComplex V c) → {i j : ι} → c.Rel i j → (C.xNext i ≅ C.X j) | true |
String.rawEndPos_ofList | Batteries.Data.String.Lemmas | ∀ (cs : List Char), (String.ofList cs).rawEndPos = { byteIdx := String.utf8Len cs } | true |
Lean.LeanOptionValue.noConfusion | Lean.Util.LeanOptions | {P : Sort u} → {t t' : Lean.LeanOptionValue} → t = t' → Lean.LeanOptionValue.noConfusionType P t t' | false |
_private.Lean.Elab.PreDefinition.Structural.FindRecArg.0.Lean.Elab.Structural.tryAllArgs.match_5 | Lean.Elab.PreDefinition.Structural.FindRecArg | (motive : Option (Lean.Elab.FixedParamPerm × Subarray Lean.Elab.FixedParamPerm) → Sort u_1) →
(x : Option (Lean.Elab.FixedParamPerm × Subarray Lean.Elab.FixedParamPerm)) →
(Unit → motive none) →
((fixedParamPerm : Lean.Elab.FixedParamPerm) →
(s' : Subarray Lean.Elab.FixedParamPerm) → motive (some (fixedParamPerm, s'))) →
motive x | false |
GaloisCoinsertion.u_l_le | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α}
(self : GaloisCoinsertion l u) (x : α), u (l x) ≤ x | true |
RestrictedProduct.instMonoidCoeOfSubmonoidClass._proof_5 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} [inst_1 : (i : ι) → Monoid (R i)] [inst_2 : ∀ (i : ι), SubmonoidClass (S i) (R i)]
(x x_1 : RestrictedProduct (fun i => R i) (fun i => ↑(B i)) 𝓕), ⇑(x * x_1) = ⇑(x * x_1) | false |
AlgebraicGeometry.Scheme.RationalMap.equivFunctionFieldOver._proof_3 | Mathlib.AlgebraicGeometry.RationalMap | ∀ {X Y S : AlgebraicGeometry.Scheme} [inst : X.Over S] [inst_1 : Y.Over S],
(fun f => f.compHom (Y ↘ S) = AlgebraicGeometry.Scheme.Hom.toRationalMap (X ↘ S)) = fun f =>
AlgebraicGeometry.Scheme.RationalMap.IsOver S f | false |
LightCondensed.lanLightCondSet._proof_1 | Mathlib.Condensed.Discrete.Colimit | ∀ (X : Type u_1),
CategoryTheory.Presheaf.IsSheaf (CategoryTheory.coherentTopology LightProfinite)
(LightCondensed.lanPresheaf (LightCondensed.locallyConstantPresheaf X)) | false |
CategoryTheory.MorphismProperty.Over.mk_left | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] {P : CategoryTheory.MorphismProperty T}
(Q : CategoryTheory.MorphismProperty T) {X A : T} (f : A ⟶ X) (hf : P f),
(CategoryTheory.MorphismProperty.Over.mk Q f hf).left = A | true |
ContDiffBump.neg | Mathlib.Analysis.Calculus.BumpFunction.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : HasContDiffBump E]
(f : ContDiffBump 0) (x : E), ↑f (-x) = ↑f x | true |
Polynomial.mahlerMeasure_one | Mathlib.Analysis.Polynomial.MahlerMeasure | Polynomial.mahlerMeasure 1 = 1 | true |
ContinuousMap.instNormOneClassOfNonempty | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} {E : Type u_3} [inst : TopologicalSpace α] [inst_1 : CompactSpace α]
[inst_2 : SeminormedAddCommGroup E] [Nonempty α] [inst_4 : One E] [NormOneClass E], NormOneClass C(α, E) | true |
Units.opEquiv._proof_9 | Mathlib.Algebra.Group.Units.Opposite | ∀ {M : Type u_1} [inst : Monoid M] (x x_1 : Mᵐᵒᵖˣ),
MulOpposite.op
{ val := MulOpposite.unop ↑(x * x_1), inv := MulOpposite.unop ↑(x * x_1)⁻¹, val_inv := ⋯, inv_val := ⋯ } =
MulOpposite.op { val := MulOpposite.unop ↑x, inv := MulOpposite.unop ↑x⁻¹, val_inv := ⋯, inv_val := ⋯ } *
MulOpposite.op { val := MulOpposite.unop ↑x_1, inv := MulOpposite.unop ↑x_1⁻¹, val_inv := ⋯, inv_val := ⋯ } | false |
_private.Lean.Meta.Tactic.FunInd.0.Lean.Tactic.FunInd.deriveInductionStructural.match_17 | Lean.Meta.Tactic.FunInd | (motive : Option (Array ℕ) → Sort u_1) →
(x : Option (Array ℕ)) → ((pos : Array ℕ) → motive (some pos)) → ((x : Option (Array ℕ)) → motive x) → motive x | false |
_private.Mathlib.Analysis.Convex.Intrinsic.0.intrinsicInterior_nonempty._simp_1_1 | Mathlib.Analysis.Convex.Intrinsic | ∀ {α : Type u} {s : Set α}, s.Nonempty = (s ≠ ∅) | false |
IdemSemiring.toSemilatticeSup | Mathlib.Algebra.Order.Kleene | {α : Type u} → [self : IdemSemiring α] → SemilatticeSup α | true |
_private.Mathlib.Topology.Sequences.0.IsSeqCompact.isComplete._simp_1_6 | Mathlib.Topology.Sequences | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | false |
CategoryTheory.Limits.CokernelCofork.IsColimit.ofId._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} (f : X ⟶ Y) {Z' : C} (x : Y ⟶ Z'),
CategoryTheory.CategoryStruct.comp f x = 0 →
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id Y) x = x | false |
_private.Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic.0.InnerProductGeometry.sin_angle._simp_1_1 | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | false |
CategoryTheory.Limits.MulticospanIndex.fstPiMapOfIsLimit | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.Limits.MulticospanShape} →
(I : CategoryTheory.Limits.MulticospanIndex J C) →
(c : CategoryTheory.Limits.Fan I.left) →
{d : CategoryTheory.Limits.Fan I.right} → CategoryTheory.Limits.IsLimit d → (c.pt ⟶ d.pt) | true |
groupHomology.d₁₀_single_inv | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G) (g : G) (a : ↑A),
((CategoryTheory.ConcreteCategory.hom (groupHomology.d₁₀ A)) fun₀ | g⁻¹ => a) =
-(CategoryTheory.ConcreteCategory.hom (groupHomology.d₁₀ A)) fun₀ | g => (A.ρ g) a | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getElem_shiftLeft._simp_1_1 | Init.Data.BitVec.Lemmas | ∀ {α : Type u_1} [inst : LE α] {x y : α}, (x ≥ y) = (y ≤ x) | false |
CategoryTheory.Limits.Bicones.functoriality._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type u_5} {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] (F : J → C) (G : CategoryTheory.Functor C D)
[G.PreservesZeroMorphisms] (A : CategoryTheory.Limits.Bicone F) (i j : J),
G.map (CategoryTheory.CategoryStruct.comp (A.ι i) (A.π j)) = if h : i = j then CategoryTheory.eqToHom ⋯ else 0 | false |
Finsupp.embDomain_trans_apply | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {M : Type u_5} [inst : AddCommMonoid M] (v : α →₀ M) (f : α ↪ β)
(g : β ↪ γ), Finsupp.embDomain (f.trans g) v = Finsupp.embDomain g (Finsupp.embDomain f v) | true |
Std.DTreeMap.Raw.getKeyD_eq_of_contains | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp], t.WF → ∀ {k fallback : α}, t.contains k = true → t.getKeyD k fallback = k | true |
Lean.Server.Test.Runner.processGenericRequest | Lean.Server.Test.Runner | Lean.Server.Test.Runner.RunnerM Unit | true |
Finset.powersetCard_card_add | Mathlib.Data.Finset.Powerset | ∀ {α : Type u_1} {n : ℕ} (s : Finset α), 0 < n → Finset.powersetCard (s.card + n) s = ∅ | true |
HopfAlgCat.MonoidalCategory.inducingFunctorData_εIso | Mathlib.Algebra.Category.HopfAlgCat.Monoidal | ∀ (R : Type u) [inst : CommRing R],
(HopfAlgCat.MonoidalCategory.inducingFunctorData R).εIso =
CategoryTheory.Iso.refl (CategoryTheory.MonoidalCategoryStruct.tensorUnit (BialgCat R)) | true |
CoxeterSystem.getElem_alternatingWord | Mathlib.GroupTheory.Coxeter.Basic | ∀ {B : Type u_1} (i j : B) (p k : ℕ) (hk : k < p),
(CoxeterSystem.alternatingWord i j p)[k] = if Even (p + k) then i else j | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.0.homotopy_congruence.match_1 | Mathlib.Algebra.Homology.HomotopyCategory | ∀ {ι : Type u_3} (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
(c : ComplexShape ι) {Y Z : HomologicalComplex V c} (x x_1 : Y ⟶ Z) (motive : homotopic V c x x_1 → Prop)
(x_2 : homotopic V c x x_1), (∀ (i : Homotopy x x_1), motive ⋯) → motive x_2 | false |
AffineEquiv.constVAdd_apply | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | ∀ (k : Type u_1) (P₁ : Type u_2) {V₁ : Type u_6} [inst : Ring k] [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁]
[inst_3 : AddTorsor V₁ P₁] (v : V₁) (x : P₁), (AffineEquiv.constVAdd k P₁ v) x = v +ᵥ x | true |
Besicovitch.TauPackage.color_lt | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} [inst : MetricSpace α] {β : Type u} [inst_1 : Nonempty β] (p : Besicovitch.TauPackage β α)
{i : Ordinal.{u}}, i < p.lastStep → ∀ {N : ℕ}, IsEmpty (Besicovitch.SatelliteConfig α N p.τ) → p.color i < N | true |
Batteries.CodeAction.TacticCodeActionEntry._sizeOf_inst | Batteries.CodeAction.Attr | SizeOf Batteries.CodeAction.TacticCodeActionEntry | false |
Monoid.PushoutI.NormalWord.Transversal.noConfusionType | Mathlib.GroupTheory.PushoutI | Sort u →
{ι : Type u_1} →
{G : ι → Type u_2} →
{H : Type u_3} →
[inst : (i : ι) → Group (G i)] →
[inst_1 : Group H] →
{φ : (i : ι) → H →* G i} →
Monoid.PushoutI.NormalWord.Transversal φ →
{ι' : Type u_1} →
{G' : ι' → Type u_2} →
{H' : Type u_3} →
[inst' : (i : ι') → Group (G' i)] →
[inst'_1 : Group H'] →
{φ' : (i : ι') → H' →* G' i} → Monoid.PushoutI.NormalWord.Transversal φ' → Sort u | false |
instRingFreeRing._proof_6 | Mathlib.RingTheory.FreeRing | ∀ (α : Type u_1) (a b : FreeRing α), a + b = b + a | false |
Lean.Grind.Order.le_eq_false_k | Init.Grind.Order | ∀ {α : Type u_1} [inst : LE α] [inst_1 : LT α] [Std.LawfulOrderLT α] [inst_3 : Std.IsPreorder α]
[inst_4 : Lean.Grind.Ring α] [Lean.Grind.OrderedRing α] {a : α} {k : ℤ}, k.blt' 0 = true → (a ≤ a + ↑k) = False | true |
Int64.instLawfulEqOrd | Init.Data.Ord.SInt | Std.LawfulEqOrd Int64 | true |
Lean.Meta.InjectionsResult.ctorIdx | Lean.Meta.Tactic.Injection | Lean.Meta.InjectionsResult → ℕ | false |
_private.Init.Data.Range.Polymorphic.SInt.0.HasModel.toNat_toInt_add_one_sub_toInt._proof_1_6 | Init.Data.Range.Polymorphic.SInt | ∀ (n : ℕ) (lo hi : BitVec (n + 1)),
¬(↑(hi.toNat + (BitVec.Signed.intMinSealed✝ (n + 1)).toNat) % ↑(2 ^ (n + 1)) + 1 -
↑(lo.toNat + (BitVec.Signed.intMinSealed✝¹ (n + 1)).toNat) % ↑(2 ^ (n + 1))).toNat =
(hi.toNat + (BitVec.Signed.intMinSealed✝² (n + 1)).toNat) % 2 ^ (n + 1) + 1 -
(lo.toNat + (BitVec.Signed.intMinSealed✝³ (n + 1)).toNat) % 2 ^ (n + 1) →
False | false |
SSet.Subcomplex.mem_ofSimplex_obj_iff | Mathlib.AlgebraicTopology.SimplicialSet.Subcomplex | ∀ {X : SSet} {n : ℕ} (x : X.obj (Opposite.op (SimplexCategory.mk n))) {m : SimplexCategoryᵒᵖ} (y : X.obj m),
y ∈ (SSet.Subcomplex.ofSimplex x).obj m ↔ ∃ f, X.map f.op x = y | true |
Batteries.Random.MersenneTwister.State._sizeOf_inst | Batteries.Data.Random.MersenneTwister | (cfg : Batteries.Random.MersenneTwister.Config) → SizeOf (Batteries.Random.MersenneTwister.State cfg) | false |
Quandle | Mathlib.Algebra.Quandle | Type u_1 → Type u_1 | true |
Std.DTreeMap.Internal.Impl.minKey?_le_minKey?_erase! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
(h : t.WF) {k km kme : α} (hkme : (Std.DTreeMap.Internal.Impl.erase! k t).minKey? = some kme),
t.minKey?.get ⋯ = km → (compare km kme).isLE = true | true |
SelectInsertParams.mk.noConfusion | Mathlib.Tactic.Widget.SelectPanelUtils | {P : Sort u} →
{pos : Lean.Lsp.Position} →
{goals : Array Lean.Widget.InteractiveGoal} →
{selectedLocations : Array Lean.SubExpr.GoalsLocation} →
{replaceRange : Lean.Lsp.Range} →
{pos' : Lean.Lsp.Position} →
{goals' : Array Lean.Widget.InteractiveGoal} →
{selectedLocations' : Array Lean.SubExpr.GoalsLocation} →
{replaceRange' : Lean.Lsp.Range} →
{ pos := pos, goals := goals, selectedLocations := selectedLocations, replaceRange := replaceRange } =
{ pos := pos', goals := goals', selectedLocations := selectedLocations',
replaceRange := replaceRange' } →
(pos = pos' →
goals = goals' → selectedLocations = selectedLocations' → replaceRange = replaceRange' → P) →
P | false |
CategoryTheory.instPreadditiveOppositeShift._proof_4 | Mathlib.CategoryTheory.Shift.Opposite | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] (A : Type u_3) [inst_1 : AddMonoid A]
[inst_2 : CategoryTheory.HasShift C A] [inst_3 : CategoryTheory.Preadditive C],
autoParam
(∀ (P Q R : CategoryTheory.OppositeShift C A) (f : P ⟶ Q) (g g' : Q ⟶ R),
CategoryTheory.CategoryStruct.comp f (g + g') =
CategoryTheory.CategoryStruct.comp f g + CategoryTheory.CategoryStruct.comp f g')
CategoryTheory.Preadditive.comp_add._autoParam | false |
Polynomial.newtonMap_apply_of_not_isUnit | Mathlib.Dynamics.Newton | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {P : Polynomial R}
{x : S}, ¬IsUnit ((Polynomial.aeval x) (Polynomial.derivative P)) → P.newtonMap x = x | true |
Nat.le_or_le_of_add_eq_add_pred | Init.Data.Nat.Lemmas | ∀ {a c b d : ℕ}, a + c = b + d - 1 → b ≤ a ∨ d ≤ c | true |
_private.Mathlib.MeasureTheory.Function.UnifTight.0.MeasureTheory.UnifTight.aeeq._simp_1_1 | Mathlib.MeasureTheory.Function.UnifTight | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | false |
_private.Mathlib.Tactic.FieldSimp.0.Mathlib.Tactic.FieldSimp.qNF.mkDivProof._unary._proof_2 | Mathlib.Tactic.FieldSimp | ∀ {v : Lean.Level} {M : Q(Type v)} (a₁ : ℤ) (x₁ : Q(«$M»)) (k₁ : ℕ) (t₁ : List ((ℤ × Q(«$M»)) × ℕ)) (a₂ : ℤ)
(x₂ : Q(«$M»)) (k₂ : ℕ) (t₂ : List ((ℤ × Q(«$M»)) × ℕ)),
(invImage (fun x => PSigma.casesOn x fun l₁ l₂ => (l₁, l₂)) Prod.instWellFoundedRelation).1 ⟨t₁, ((a₂, x₂), k₂) :: t₂⟩
⟨((a₁, x₁), k₁) :: t₁, ((a₂, x₂), k₂) :: t₂⟩ | false |
SzemerediRegularity.bound.eq_1 | Mathlib.Combinatorics.SimpleGraph.Regularity.Lemma | ∀ (ε : ℝ) (l : ℕ),
SzemerediRegularity.bound ε l =
SzemerediRegularity.stepBound^[⌊4 / ε ^ 5⌋₊] (SzemerediRegularity.initialBound ε l) *
16 ^ SzemerediRegularity.stepBound^[⌊4 / ε ^ 5⌋₊] (SzemerediRegularity.initialBound ε l) | true |
CategoryTheory.eq_of_comp_left_eq' | Mathlib.CategoryTheory.Category.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y),
((fun {Z} h => CategoryTheory.CategoryStruct.comp f h) = fun {Z} h => CategoryTheory.CategoryStruct.comp g h) → f = g | true |
_private.Mathlib.Analysis.LocallyConvex.WithSeminorms.0.WithSeminorms.isVonNBounded_iff_seminorm_bddAbove._simp_1_1 | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α}, BddAbove s = ∃ x, ∀ y ∈ s, y ≤ x | false |
Pi.uniformSpace_comap_restrict | Mathlib.Topology.UniformSpace.Pi | ∀ {ι : Type u_1} (α : ι → Type u) [U : (i : ι) → UniformSpace (α i)] (S : Set ι),
UniformSpace.comap S.restrict (Pi.uniformSpace fun i => α ↑i) = ⨅ i ∈ S, UniformSpace.comap (Function.eval i) (U i) | true |
Circle.instCommGroup._proof_21 | Mathlib.Analysis.Complex.Circle | autoParam
(∀ (n : ℕ) (a : Circle),
Circle.instCommGroup._aux_17 (Int.negSucc n) a = (Circle.instCommGroup._aux_17 (↑n.succ) a)⁻¹)
DivInvMonoid.zpow_neg'._autoParam | false |
CategoryTheory.MorphismProperty.HasRightCalculusOfFractions | Mathlib.CategoryTheory.Localization.CalculusOfFractions | {C : Type u_1} → [inst : CategoryTheory.Category.{v_1, u_1} C] → CategoryTheory.MorphismProperty C → Prop | true |
Finset.Pi.cons_injective | Mathlib.Data.Finset.Pi | ∀ {α : Type u_1} {δ : α → Sort v} [inst : DecidableEq α] {a : α} {b : δ a} {s : Finset α},
a ∉ s → Function.Injective (Finset.Pi.cons s a b) | true |
_private.Lean.Elab.DocString.Builtin.Parsing.0.Lean.Doc.parseQuotedStrLit.repositionSyntax | Lean.Elab.DocString.Builtin.Parsing | Lean.FileMap → String.Pos.Raw → String → Lean.Syntax → Lean.Syntax | true |
Aesop.Frontend.Feature.priority | Aesop.Frontend.RuleExpr | Aesop.Frontend.Priority → Aesop.Frontend.Feature | true |
_private.Mathlib.Combinatorics.SimpleGraph.Copy.0.SimpleGraph.killCopies_eq_left._simp_1_7 | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {α : Sort u_3} {p : Nonempty α → Prop}, (∀ (h : Nonempty α), p h) = ∀ (a : α), p ⋯ | false |
Function.Periodic.differentiable_qParam | Mathlib.Analysis.Complex.Periodic | ∀ {h : ℝ}, Differentiable ℂ (Function.Periodic.qParam h) | true |
Lean.Expr.NumApps.State.rec | Lean.Util.NumApps | {motive : Lean.Expr.NumApps.State → Sort u} →
((visited : Lean.PtrSet Lean.Expr) →
(counters : Lean.NameMap ℕ) → motive { visited := visited, counters := counters }) →
(t : Lean.Expr.NumApps.State) → motive t | false |
_private.Mathlib.AlgebraicGeometry.Limits.0.AlgebraicGeometry.IsAffineOpen.iSup_of_disjoint_aux | Mathlib.AlgebraicGeometry.Limits | ∀ {ι : Type u} {X : AlgebraicGeometry.Scheme} [Finite ι] {U : ι → X.Opens},
(∀ (i : ι), AlgebraicGeometry.IsAffineOpen (U i)) →
Pairwise (Function.onFun Disjoint U) → AlgebraicGeometry.IsAffineOpen (iSup U) | true |
Lean.Elab.Tactic.Do.ProofMode.mCasesExists | Lean.Elab.Tactic.Do.ProofMode.Cases | {α : Type} →
Lean.Expr →
Lean.TSyntax `Lean.binderIdent →
(Lean.Expr → Lean.MetaM (α × Lean.Elab.Tactic.Do.ProofMode.MGoal × Lean.Expr)) →
Lean.MetaM (α × Lean.Elab.Tactic.Do.ProofMode.MGoal × Lean.Expr) | true |
_private.Mathlib.Data.List.Intervals.0.List.Ico.inter_consecutive._simp_1_2 | Mathlib.Data.List.Intervals | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | false |
Lean.Elab.Term.withMacroExpansion | Lean.Elab.Term.TermElabM | {n : Type → Type u_1} →
{α : Type} → [Monad n] → [MonadControlT Lean.Elab.TermElabM n] → Lean.Syntax → Lean.Syntax → n α → n α | true |
Function.Embedding.sigmaSet._proof_1 | Mathlib.Logic.Embedding.Set | ∀ {α : Type u_1} {ι : Type u_2} {s : ι → Set α},
Pairwise (Function.onFun Disjoint s) → Function.Injective fun x => ↑x.snd | false |
_private.Mathlib.LinearAlgebra.Reflection.0.Module.reflection_mul_reflection_pow_apply._proof_1_2 | Mathlib.LinearAlgebra.Reflection | ∀ (m : ℕ), ↑m % 2 = 0 ∨ ↑m % 2 = 1 | false |
Configuration.ProjectivePlane.lineCount_eq | Mathlib.Combinatorics.Configuration | ∀ {P : Type u_1} (L : Type u_2) [inst : Membership P L] [inst_1 : Configuration.ProjectivePlane P L] [Finite P]
[Finite L] (p : P), Configuration.lineCount L p = Configuration.ProjectivePlane.order P L + 1 | true |
_private.Lean.Meta.ExprLens.0.Lean.Core.viewBindersCoord.match_1 | Lean.Meta.ExprLens | (motive : ℕ → Lean.Expr → Sort u_1) →
(x : ℕ) →
(x_1 : Lean.Expr) →
((n : Lean.Name) →
(y body : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive 1 (Lean.Expr.lam n y body binderInfo)) →
((n : Lean.Name) →
(y body : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive 1 (Lean.Expr.forallE n y body binderInfo)) →
((n : Lean.Name) →
(y value body : Lean.Expr) → (nondep : Bool) → motive 2 (Lean.Expr.letE n y value body nondep)) →
((x : ℕ) → (x_2 : Lean.Expr) → motive x x_2) → motive x x_1 | false |
BoundedVariationOn.stieltjesFunctionRightLim.congr_simp | Mathlib.MeasureTheory.VectorMeasure.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderTopology α] {E : Type u_2}
[inst_3 : NormedAddCommGroup E] [inst_4 : CompleteSpace E] {f f_1 : α → E} (e_f : f = f_1)
(hf : BoundedVariationOn f Set.univ) (x₀ x₀_1 : α),
x₀ = x₀_1 → hf.stieltjesFunctionRightLim x₀ = ⋯.stieltjesFunctionRightLim x₀_1 | true |
PresheafOfModules.limitPresheafOfModules_obj | Mathlib.Algebra.Category.ModuleCat.Presheaf.Limits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {J : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} J] (F : CategoryTheory.Functor J (PresheafOfModules R))
[inst_2 :
∀ (X : Cᵒᵖ),
Small.{v, max u₂ v}
↑((F.comp (PresheafOfModules.evaluation R X)).comp (CategoryTheory.forget (ModuleCat ↑(R.obj X)))).sections]
(X : Cᵒᵖ),
(PresheafOfModules.limitPresheafOfModules F).obj X =
CategoryTheory.Limits.limit (F.comp (PresheafOfModules.evaluation R X)) | true |
SSet.Truncated.StrictSegal.spine_δ_arrow_lt | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ {n : ℕ} {X : SSet.Truncated (n + 1)} (sx : X.StrictSegal) (m : ℕ) (h : m ≤ n) (f : X.Path (m + 1)) {i : Fin m}
{j : Fin (m + 2)},
i.succ.castSucc < j →
(X.spine m ⋯
(X.map (SimplexCategory.Truncated.Hom.tr (SimplexCategory.δ j) ⋯ ⋯).op
(sx.spineToSimplex (m + 1) ⋯ f))).arrow
i =
f.arrow i.castSucc | true |
Subalgebra.instCommRingSubtypeMemCenter._proof_10 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} [inst : CommSemiring R] {A : Type u_1} [inst_1 : Ring A] [inst_2 : Algebra R A],
autoParam
(∀ (n : ℕ) (a : ↥(Subalgebra.center R A)),
Subalgebra.instCommRingSubtypeMemCenter._aux_6 (Int.negSucc n) a =
-Subalgebra.instCommRingSubtypeMemCenter._aux_6 (↑n.succ) a)
SubNegMonoid.zsmul_neg'._autoParam | false |
Aesop.UnfoldRule.mk | Aesop.Rule | Lean.Name → Option Lean.Name → Aesop.UnfoldRule | true |
intervalIntegral.FTCFilter.nhdsUniv | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ (a : ℝ), intervalIntegral.FTCFilter a (nhdsWithin a Set.univ) (nhds a) | true |
AddSubsemigroup.closureAddCommSemigroupOfComm.match_1 | Mathlib.GroupTheory.Subsemigroup.Centralizer | ∀ (M : Type u_1) [inst : AddSemigroup M] {s : Set M} (motive : ↥(AddSubsemigroup.closure s) → Prop)
(x : ↥(AddSubsemigroup.closure s)), (∀ (val : M) (h₂ : val ∈ AddSubsemigroup.closure s), motive ⟨val, h₂⟩) → motive x | false |
AddCircle.haarAddCircle._proof_2 | Mathlib.Analysis.Fourier.AddCircle | ∀ {T : ℝ}, IsTopologicalAddGroup (ℝ ⧸ AddSubgroup.zmultiples T) | false |
_private.Batteries.Data.List.Count.0.List.idxToSigmaCount_sigmaCountToIdx._proof_1_65 | Batteries.Data.List.Count | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] {xs : List α} {xc : (x : α) × Fin (List.count x xs)},
↑(cast ⋯ xc.snd) < (List.filter (fun x => x == xc.fst) xs).length | false |
Lean.Elab.Tactic.MkSimpContextResult.ctorIdx | Lean.Elab.Tactic.Simp | Lean.Elab.Tactic.MkSimpContextResult → ℕ | false |
CategoryTheory.Adjunction.rightAdjointLaxMonoidal | Mathlib.CategoryTheory.Monoidal.Functor | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D C} → (F ⊣ G) → [F.OplaxMonoidal] → G.LaxMonoidal | true |
Valuation.IsRankOneDiscrete.generator_ne_zero | Mathlib.RingTheory.Valuation.Discrete.Basic | ∀ {Γ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ] {A : Type u_2} [inst_1 : Ring A] (v : Valuation A Γ)
[inst_2 : v.IsRankOneDiscrete], ↑(Valuation.IsRankOneDiscrete.generator v) ≠ 0 | true |
CategoryTheory.MorphismProperty.RightFraction₂.mk.sizeOf_spec | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W : CategoryTheory.MorphismProperty C} {X Y : C}
[inst_1 : SizeOf C] [inst_2 : ⦃X Y : C⦄ → (x : X ⟶ Y) → SizeOf (W x)] {X' : C} (s : X' ⟶ X) (hs : W s)
(f f' : X' ⟶ Y),
sizeOf { X' := X', s := s, hs := hs, f := f, f' := f' } = 1 + sizeOf X' + sizeOf s + sizeOf hs + sizeOf f + sizeOf f' | true |
Lean.Widget.MsgToInteractive.mk.noConfusion | Lean.Server.FileWorker.WidgetRequests | {P : Sort u} →
{msg : Lean.Server.WithRpcRef Lean.MessageData} →
{indent : ℕ} →
{msg' : Lean.Server.WithRpcRef Lean.MessageData} →
{indent' : ℕ} →
{ msg := msg, indent := indent } = { msg := msg', indent := indent' } →
(msg = msg' → indent = indent' → P) → P | false |
Equiv.sigmaEquivOptionOfInhabited.match_1 | Mathlib.Logic.Equiv.Sum | ∀ (α : Type u_1) [inst : Inhabited α] (motive : Option { a // a ≠ default } → Prop) (x : Option { a // a ≠ default }),
(∀ (a : Unit), motive none) → (∀ (val : α) (ha : val ≠ default), motive (some ⟨val, ha⟩)) → motive x | false |
AlgebraicTopology.DoldKan.Compatibility.equivalence₁CounitIso_hom_app | Mathlib.AlgebraicTopology.DoldKan.Compatibility | ∀ {A : Type u_1} {A' : Type u_2} {B' : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} A'] [inst_2 : CategoryTheory.Category.{v_4, u_4} B'] {eA : A ≌ A'}
{e' : A' ≌ B'} {F : CategoryTheory.Functor A B'} (hF : eA.functor.comp e'.functor ≅ F) (X : B'),
(AlgebraicTopology.DoldKan.Compatibility.equivalence₁CounitIso hF).hom.app X =
CategoryTheory.CategoryStruct.comp (hF.inv.app (eA.inverse.obj (e'.inverse.obj X)))
(CategoryTheory.CategoryStruct.comp (e'.functor.map (eA.counitIso.hom.app (e'.inverse.obj X)))
(e'.counitIso.hom.app X)) | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.le_intMin_of_msb_eq_false.match_1_1 | Init.Data.BitVec.Lemmas | ∀ (motive : (w : ℕ) → {x : BitVec w} → x.msb = false → Prop) (w : ℕ) {x : BitVec w} (hx : x.msb = false),
(∀ (x : BitVec 0) (hx : x.msb = false), motive 0 hx) →
(∀ (w' : ℕ) (x : BitVec (w' + 1)) (hx : x.msb = false), motive w'.succ hx) → motive w hx | false |
MvFunctor._aux_Mathlib_Data_TypeVec___unexpand_TypeVec_Arrow_1 | Mathlib.Data.TypeVec | Lean.PrettyPrinter.Unexpander | false |
SimplexCategory.Truncated.δ₂_zero_eq_const | Mathlib.AlgebraicTopology.SimplexCategory.Truncated | SimplexCategory.Truncated.δ₂ 0 SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_4
SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_3 =
SimplexCategory.Truncated.Hom.tr ((SimplexCategory.mk 0).const (SimplexCategory.mk (0 + 1)) 1)
SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_4 SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_3 | true |
Finset.map_add_right_Ico | Mathlib.Algebra.Order.Interval.Finset.Basic | ∀ {α : Type u_2} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedCancelAddMonoid α]
[ExistsAddOfLE α] [inst_4 : LocallyFiniteOrder α] (a b c : α),
Finset.map (addRightEmbedding c) (Finset.Ico a b) = Finset.Ico (a + c) (b + c) | true |
CategoryTheory.Subfunctor.ofSection_le_iff | Mathlib.CategoryTheory.Subfunctor.OfSection | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : Cᵒᵖ}
(x : F.obj X) (G : CategoryTheory.Subfunctor F), CategoryTheory.Subfunctor.ofSection x ≤ G ↔ x ∈ G.obj X | true |
_private.Mathlib.FieldTheory.AlgebraicClosure.0.map_mem_algebraicClosure_iff._simp_1_2 | Mathlib.FieldTheory.AlgebraicClosure | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : Ring B] [inst_2 : Algebra A B] {x : B} [Nontrivial A],
IsIntegral A x = (minpoly A x ≠ 0) | false |
Std.DHashMap.Const.getD_insertIfNew | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] {k a : α} {fallback v : β},
Std.DHashMap.Const.getD (m.insertIfNew k v) a fallback =
if (k == a) = true ∧ k ∉ m then v else Std.DHashMap.Const.getD m a fallback | true |
_private.Init.Data.List.Sublist.0.List.filterMap_subset._simp_1_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} {β : Type u_2} {f : α → Option β} {l : List α} {b : β},
(b ∈ List.filterMap f l) = ∃ a ∈ l, f a = some b | false |
Lean.Elab.ContextInfo.runMetaM | Lean.Elab.InfoTree.Main | {α : Type} → Lean.Elab.ContextInfo → Lean.LocalContext → Lean.MetaM α → IO α | true |
Finset.Int.finsetGcd_nonneg | Mathlib.Algebra.GCDMonoid.Finset | ∀ {ι : Type u_1} {s : Finset ι} {f : ι → ℤ}, 0 ≤ s.gcd f | true |
Primcodable.sum._proof_2 | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_2} {β : Type u_1} [inst : Primcodable α] [inst_1 : Primcodable β] (n : ℕ),
Encodable.encode
(bif n.bodd then Option.map (fun b => 2 * Encodable.encode (n, b).2 + 1) (Encodable.decode n.div2)
else Option.map (fun b => 2 * Encodable.encode (n, b).2) (Encodable.decode n.div2)) =
Encodable.encode (Encodable.decodeSum n) | false |
Submodule.quotEquivOfEqBot_apply_mk | Mathlib.LinearAlgebra.Quotient.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M)
(hp : p = ⊥) (x : M), (p.quotEquivOfEqBot hp) (Submodule.Quotient.mk x) = x | true |
Submonoid.mrange_snd | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N],
MonoidHom.mrange (MonoidHom.snd M N) = ⊤ | true |
Std.DHashMap.Internal.Raw₀.insertMany_list_singleton | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] {k : α}
{v : β k}, ↑(m.insertMany [⟨k, v⟩]) = m.insert k v | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.