name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Elab.Do.elabNestedAction | Lean.Elab.Do.Basic | Lean.Elab.Term.TermElab | true |
WType.Listα.cons | Mathlib.Data.W.Constructions | {γ : Type u} → γ → WType.Listα γ | true |
_private.Lean.Meta.Tactic.SplitIf.0.Lean.Meta.initFn._@.Lean.Meta.Tactic.SplitIf.3526097586._hygCtx._hyg.2 | Lean.Meta.Tactic.SplitIf | IO Unit | false |
Turing.ToPartrec.Code.zero_eval | Mathlib.Computability.TuringMachine.Config | ∀ (v : List ℕ), Turing.ToPartrec.Code.zero.eval v = pure [0] | true |
Mathlib.Tactic.BicategoryLike.State.mk._flat_ctor | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Lean.PersistentExprMap Mathlib.Tactic.BicategoryLike.Mor₁ → Mathlib.Tactic.BicategoryLike.State | false |
Subgroup.zpow._proof_1 | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) (a : ↥H) (n : ℤ), ↑a ^ n ∈ H | false |
Std.ExtDHashMap.Const.getKey?_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtDHashMap α fun x => Unit} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {l : List α} {k k' : α},
(k == k') = true →
k ∉ m →
List.Pairwise (fun a b => (a == b) = false) l →
k ∈ l → (Std.ExtDHashMap.Const.insertManyIfNewUnit m l).getKey? k'... | true |
Array.PrefixTable.step._proof_12 | Batteries.Data.Array.Match | ∀ {α : Type u_1} (t : Array.PrefixTable α) (k : ℕ),
k + 1 < t.size + 1 → ∀ (h2 : k < t.size), t.toArray[k].2 < k + 1 → t.toArray[k].2 < t.size + 1 | false |
Matrix.PosSemidef.kronecker | Mathlib.Analysis.Matrix.Order | ∀ {𝕜 : Type u_1} {n : Type u_2} [inst : RCLike 𝕜] [Finite n] {m : Type u_3} [Finite m] {x : Matrix n n 𝕜}
{y : Matrix m m 𝕜}, x.PosSemidef → y.PosSemidef → (Matrix.kroneckerMap (fun x1 x2 => x1 * x2) x y).PosSemidef | true |
_private.Mathlib.Data.Nat.Factorial.DoubleFactorial.0.Nat.doubleFactorial.match_1.eq_2 | Mathlib.Data.Nat.Factorial.DoubleFactorial | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1) (h_3 : (k : ℕ) → motive k.succ.succ),
(match 1 with
| 0 => h_1 ()
| 1 => h_2 ()
| k.succ.succ => h_3 k) =
h_2 () | true |
Sym2.coe_map | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (z : Sym2 α), ↑(Sym2.map f z) = f '' ↑z | true |
_private.Mathlib.CategoryTheory.Limits.Preserves.Shapes.Zero.0.CategoryTheory.Functor.map_isZero._simp_1_1 | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (X : C),
CategoryTheory.Limits.IsZero X = (CategoryTheory.CategoryStruct.id X = 0) | false |
Multiset.sup_eq_union | Mathlib.Data.Multiset.UnionInter | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Multiset α), s ⊔ t = s ∪ t | true |
Aesop.ForwardRuleStateStats._sizeOf_1 | Aesop.Stats.Basic | Aesop.ForwardRuleStateStats → ℕ | false |
MonoidHom.id._proof_1 | Mathlib.Algebra.Group.Hom.Defs | ∀ (M : Type u_1) [inst : MulOne M], 1 = 1 | false |
Ideal.comap._proof_3 | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_1} {S : Type u_2} {F : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
(f : F) [RingHomClass F R S] (I : Ideal S) {x y : R}, x ∈ ⇑f ⁻¹' ↑I → y ∈ ⇑f ⁻¹' ↑I → x + y ∈ ⇑f ⁻¹' ↑I | false |
NormedCommRing.toNonUnitalNormedCommRing._proof_12 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} [β : NormedCommRing α] (x y : α), dist x y = ‖-x + y‖ | false |
Homotopy.symm._proof_1 | Mathlib.Algebra.Homology.Homotopy | ∀ {ι : Type u_3} {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C D : HomologicalComplex V c} {f g : C ⟶ D} (h : Homotopy f g) (i j : ι),
¬c.Rel j i → (-h.hom) i j = 0 | false |
IsAddQuotientCoveringMap.homeomorph_comp_iff | Mathlib.Topology.Covering.Quotient | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {f : E → X} {G : Type u_3}
[inst_2 : AddGroup G] [inst_3 : AddAction G E] {Y : Type u_4} [inst_4 : TopologicalSpace Y] (φ : X ≃ₜ Y),
IsAddQuotientCoveringMap (⇑φ ∘ f) G ↔ IsAddQuotientCoveringMap f G | true |
Valued.integer.norm_unit | Mathlib.Topology.Algebra.Valued.LocallyCompact | ∀ {K : Type u_1} [inst : NontriviallyNormedField K] [inst_1 : IsUltrametricDist K] (u : (↥(Valued.integer K))ˣ),
‖↑u‖ = 1 | true |
NumberField.instCommRingRingOfIntegers._proof_31 | Mathlib.NumberTheory.NumberField.Basic | ∀ (K : Type u_1) [inst : Field K],
autoParam
(∀ (n : ℕ) (x : NumberField.RingOfIntegers K),
NumberField.instCommRingRingOfIntegers._aux_28 K (n + 1) x =
NumberField.instCommRingRingOfIntegers._aux_28 K n x * x)
Monoid.npow_succ._autoParam | false |
_private.Lean.Meta.Tactic.Cleanup.0.Lean.Meta.cleanupCore.addUsedFVars._unsafe_rec | Lean.Meta.Tactic.Cleanup | Lean.Expr → StateRefT' IO.RealWorld (Bool × Lean.FVarIdSet) Lean.MetaM Unit | false |
CategoryTheory.GradedObject.CofanMapObjFun.inj_iso_hom | Mathlib.CategoryTheory.GradedObject | ∀ {I : Type u_1} {J : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{v_1, u_4} C]
{X : CategoryTheory.GradedObject I C} {p : I → J} {j : J} [inst_1 : X.HasMap p] {c : X.CofanMapObjFun p j}
(hc : CategoryTheory.Limits.IsColimit c) (i : I) (hi : p i = j),
CategoryTheory.CategoryStruct.comp (CategoryTheor... | true |
Std.Sat.CNF.Clause.Mem | Std.Sat.CNF.Basic | {α : Type u_1} → α → Std.Sat.CNF.Clause α → Prop | true |
geom_sum₂_Ico | Mathlib.Algebra.Field.GeomSum | ∀ {K : Type u_2} [inst : Field K] {x y : K},
x ≠ y → ∀ {m n : ℕ}, m ≤ n → ∑ i ∈ Finset.Ico m n, x ^ i * y ^ (n - 1 - i) = (x ^ n - y ^ (n - m) * x ^ m) / (x - y) | true |
Lean.Parser.Term.binderTactic.parenthesizer | Lean.Parser.Term.Basic | Lean.PrettyPrinter.Parenthesizer | true |
CategoryTheory.Triangulated.TStructure.ge | Mathlib.CategoryTheory.Triangulated.TStructure.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasZeroObject C] →
[inst_3 : CategoryTheory.HasShift C ℤ] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[inst_5 : Ca... | true |
_private.Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace.0.RestrictedProduct.continuous_dom_pi._simp_1_1 | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
Continuous f = ∀ (x : X), ContinuousAt f x | false |
_private.Lean.Linter.UnusedVariables.0.Lean.Linter.mkIgnoreFnImpl.match_3 | Lean.Linter.UnusedVariables | (motive : Lean.ImportM.Context → Sort u_1) →
(__discr : Lean.ImportM.Context) →
((env : Lean.Environment) → (opts : Lean.Options) → motive { env := env, opts := opts }) → motive __discr | false |
Polynomial.resultant_taylor | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (r : R),
((Polynomial.taylor r) f).resultant ((Polynomial.taylor r) g) = f.resultant g | true |
TestFunction.toBoundedContinuousFunctionCLM._proof_1 | Mathlib.Analysis.Distribution.TestFunction | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F], IsBoundedSMul ℝ F | false |
List.mkSlice_rii_eq_mkSlice_rci | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : List α}, Std.Rii.Sliceable.mkSlice xs *...* = Std.Rci.Sliceable.mkSlice xs 0...* | true |
Int8.toNatClampNeg_eq_zero_iff._simp_1 | Init.Data.SInt.Lemmas | ∀ {n : Int8}, (n.toNatClampNeg = 0) = (n ≤ 0) | false |
USize.eq_of_toFin_eq | Init.Data.UInt.Lemmas | ∀ {a b : USize}, a.toFin = b.toFin → a = b | true |
Std.TreeSet.getD_maxD | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp],
t.isEmpty = false → ∀ {fallback fallback' : α}, t.getD (t.maxD fallback) fallback' = t.maxD fallback | true |
_private.Mathlib.Data.Sym.Basic.0.Sym.count_coe_fill_of_ne._simp_1_1 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {a b : α} {n : ℕ}, (b ∈ Multiset.replicate n a) = (n ≠ 0 ∧ b = a) | false |
Nat.chineseRemainderOfList.match_1 | Mathlib.Data.Nat.ChineseRemainder | {ι : Type u_1} →
(s : ι → ℕ) →
(motive : (x : List ι) → List.Pairwise (Function.onFun Nat.Coprime s) x → Sort u_2) →
(x : List ι) →
(x_1 : List.Pairwise (Function.onFun Nat.Coprime s) x) →
((x : List.Pairwise (Function.onFun Nat.Coprime s) []) → motive [] x) →
((i : ι) →
... | false |
AddConstEquiv.instPowInt._proof_1 | Mathlib.Algebra.AddConstMap.Equiv | ∀ {G : Type u_1} [inst : Add G] {a : G} (e : AddConstEquiv G G a a) (n : ℤ) (x : G),
(↑e ^ n).toFun (x + a) = (↑e ^ n).toFun x + a | false |
IsCoxeterGroup | Mathlib.GroupTheory.Coxeter.Basic | (W : Type u) → [Group W] → Prop | true |
Real.HolderTriple.holderConjugate_div_div | Mathlib.Data.Real.ConjExponents | ∀ {p q r : ℝ}, p.HolderTriple q r → (p / r).HolderConjugate (q / r) | true |
MonoidAlgebra.mapRingHom_comp_algebraMap | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_1} {S : Type u_2} {M : Type u_7} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Monoid M]
(f : R →+* S),
(MonoidAlgebra.mapRingHom M f).comp (algebraMap R (MonoidAlgebra R M)) = (algebraMap S (MonoidAlgebra S M)).comp f | true |
_private.Lean.Compiler.LCNF.Main.0.Lean.Compiler.LCNF.PassManager.run.match_3 | Lean.Compiler.LCNF.Main | (motive : Option (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Phase.mono.toPurity) → Sort u_1) →
(__do_lift : Option (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Phase.mono.toPurity)) →
((decl : Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Phase.mono.toPurity) → motive (some decl)) →
((x : Option (Lean.Compiler... | false |
HasStrictFDerivAt.log | Mathlib.Analysis.SpecialFunctions.Log.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {x : E} {f' : StrongDual ℝ E},
HasStrictFDerivAt f f' x → f x ≠ 0 → HasStrictFDerivAt (fun x => Real.log (f x)) ((f x)⁻¹ • f') x | true |
LinearMap.vecEmpty | Mathlib.LinearAlgebra.Pi | {R : Type u} →
{M : Type v} →
{M₃ : Type y} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid M₃] → [inst_3 : Module R M] → [inst_4 : Module R M₃] → M →ₗ[R] Fin 0 → M₃ | true |
_private.Mathlib.NumberTheory.RamificationInertia.Basic.0.Ideal.FinrankQuotientMap.linearIndependent_of_nontrivial._simp_1_7 | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N] {G : Type u_7}
[inst_2 : FunLike G M N] [AddMonoidHomClass G M N] (g : G) (f : ι → M) (s : Finset ι),
∑ x ∈ s, g (f x) = g (∑ x ∈ s, f x) | false |
_private.Mathlib.GroupTheory.Descent.0.Group.fg_of_descent._simp_1_6 | Mathlib.GroupTheory.Descent | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | false |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.step₂.quasiIsoAt_ι._proof_1_1 | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ (n : ℤ), n ≤ n | false |
_private.Init.Data.Dyadic.Round.0.Dyadic.precision_roundDown.match_1_1 | Init.Data.Dyadic.Round | ∀ (motive : Dyadic → Prop) (x : Dyadic),
(∀ (a : Unit), motive Dyadic.zero) → (∀ (n k : ℤ) (hn : n % 2 = 1), motive (Dyadic.ofOdd n k hn)) → motive x | false |
Finset.pimage_eq_image_filter | Mathlib.Data.Finset.PImage | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α →. β} [inst_1 : (x : α) → Decidable (f x).Dom]
{s : Finset α}, Finset.pimage f s = Finset.image (fun x => (f ↑x).get ⋯) {x ∈ s | (f x).Dom}.attach | true |
AlgebraicGeometry.PrimeSpectrum.Top.eq_1 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ (R : Type u) [inst : CommRing R], AlgebraicGeometry.PrimeSpectrum.Top R = TopCat.of (PrimeSpectrum R) | true |
AlgebraicGeometry.Scheme.Hom.normalizationCoprodIso._proof_4 | Mathlib.AlgebraicGeometry.Normalization | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [inst : AlgebraicGeometry.QuasiCompact f]
[inst_1 : AlgebraicGeometry.QuasiSeparated f] {U V : AlgebraicGeometry.Scheme} {iU : U ⟶ X} {iV : V ⟶ X}
(e : CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.BinaryCofan.mk iU iV))
[inst_2 : AlgebraicGeometry.QuasiComp... | false |
ENNReal.mulRightOrderIso._proof_2 | Mathlib.Data.ENNReal.Inv | ∀ (a : ENNReal) (ha : IsUnit a) {a_1 b : ENNReal}, ha.unit.mulRight a_1 ≤ ha.unit.mulRight b ↔ a_1 ≤ b | false |
CategoryTheory.MonoidalCategory.DayConvolution.unit_uniqueUpToIso_hom_assoc | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {V : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} V]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalCategory V]
{F G : CategoryTheory.Functor C V} (h h' : CategoryTheory.MonoidalCategory.DayConvolution F G)
{Z : Cate... | true |
Asymptotics.isLittleOTVS_fun_neg_right | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] {l : Filter α} {f : α → E} {g : α → F} [ContinuousNeg F],
... | true |
aemeasurable_inv_iff._simp_2 | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {α : Type u_3} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {G : Type u_4} [inst : InvolutiveInv G]
[inst_1 : MeasurableSpace G] [MeasurableInv G] {f : α → G}, AEMeasurable (fun x => (f x)⁻¹) μ = AEMeasurable f μ | false |
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.Combination.0.Set.powersetCard.stabilizer_coe._simp_1_3 | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | false |
MDifferentiableWithinAt.neg | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | true |
IO.Process.Output.stderr | Init.System.IO | IO.Process.Output → String | true |
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.getLitAux.match_1 | Lean.Compiler.LCNF.Simp.ConstantFold | (motive : Option ℕ → Sort u_1) →
(__discr : Option ℕ) → ((natLit : ℕ) → motive (some natLit)) → ((x : Option ℕ) → motive x) → motive __discr | false |
Equiv.subRight.eq_1 | Mathlib.Algebra.Group.Units.Equiv | ∀ {G : Type u_5} [inst : AddGroup G] (a : G),
Equiv.subRight a = { toFun := fun b => b - a, invFun := fun b => b + a, left_inv := ⋯, right_inv := ⋯ } | true |
Lean.Elab.Attribute.kind | Lean.Elab.Attributes | Lean.Elab.Attribute → Lean.AttributeKind | true |
RingPreordering.support.congr_simp | Mathlib.Algebra.Order.Ring.Ordering.Basic | ∀ {R : Type u_1} [inst : CommRing R] (P P_1 : RingPreordering R) (e_P : P = P_1) [inst_1 : P.HasIdealSupport],
P.support = P_1.support | true |
MeasurableEmbedding.measurable | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {f : α → β},
MeasurableEmbedding f → Measurable f | true |
CategoryTheory.HasProjectiveResolution | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasZeroObject C] → [CategoryTheory.Limits.HasZeroMorphisms C] → C → Prop | true |
TrivialLieModule.instLieRingModule._proof_1 | Mathlib.Algebra.Lie.Abelian | ∀ (R : Type u_1) (L : Type u_2) (M : Type u_3) [inst : AddCommGroup M] (x y : L) (m : TrivialLieModule R L M), 0 = 0 + 0 | false |
CategoryTheory.IsSplitEpi.mk | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f : X ⟶ Y},
Nonempty (CategoryTheory.SplitEpi f) → CategoryTheory.IsSplitEpi f | true |
instContMDiffVectorBundleOfNatWithTopENat_1 | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {𝕜 : Type u_1} {B : Type u_2} (F : Type u_4) (E : B → Type u_6) [inst : NontriviallyNormedField 𝕜] {EB : Type u_7}
[inst_1 : NormedAddCommGroup EB] [inst_2 : NormedSpace 𝕜 EB] {HB : Type u_8} [inst_3 : TopologicalSpace HB]
{IB : ModelWithCorners 𝕜 EB HB} [inst_4 : TopologicalSpace B] [inst_5 : ChartedSpace HB... | true |
Finset.bipartiteAbove_swap | Mathlib.Combinatorics.Enumerative.DoubleCounting | ∀ {α : Type u_2} {β : Type u_3} (r : α → β → Prop) (s : Finset α) (b : β) [inst : (a : α) → Decidable (r a b)],
Finset.bipartiteAbove (Function.swap r) s b = Finset.bipartiteBelow r s b | true |
PSet.Equiv._unsafe_rec | Mathlib.SetTheory.ZFC.PSet | PSet.{u_1} → PSet.{u_2} → Prop | false |
AddCommute.add_left._simp_1 | Mathlib.Algebra.Group.Commute.Defs | ∀ {S : Type u_3} [inst : AddSemigroup S] {a b c : S}, AddCommute a c → AddCommute b c → AddCommute (a + b) c = True | false |
_private.Mathlib.NumberTheory.Height.NumberField.0.Mathlib.Meta.Positivity.evalHeightTotalWeight._proof_1 | Mathlib.NumberTheory.Height.NumberField | ∀ (α : Q(Type)) (x : Q(Zero «$α»)) (__defeqres : PLift («$x» =Q Nat.instMulZeroClass.toZero)),
«$x» =Q Nat.instMulZeroClass.toZero | false |
Lean.Meta.FVarSubst.mk.injEq | Lean.Meta.Tactic.FVarSubst | ∀ (map map_1 : Lean.AssocList Lean.FVarId Lean.Expr), ({ map := map } = { map := map_1 }) = (map = map_1) | true |
Fin.range_castLE | Mathlib.Data.Fin.SuccPred | ∀ {n k : ℕ} (h : n ≤ k), Set.range (Fin.castLE h) = {i | ↑i < n} | true |
_private.Lean.Meta.Match.SolveOverlap.0.Lean.Meta.Match.injectionAny.match_1 | Lean.Meta.Match.SolveOverlap | (motive : Lean.Meta.InjectionResult → Sort u_1) →
(__do_lift : Lean.Meta.InjectionResult) →
(Unit → motive Lean.Meta.InjectionResult.solved) →
((mvarId : Lean.MVarId) →
(newEqs : Array Lean.FVarId) →
(remainingNames : List Lean.Name) →
motive (Lean.Meta.InjectionResult.su... | false |
DistribSMul.compFun | Mathlib.Algebra.GroupWithZero.Action.Defs | {M : Type u_1} →
{N : Type u_6} → (A : Type u_7) → [inst : AddZeroClass A] → [DistribSMul M A] → (N → M) → DistribSMul N A | true |
Polynomial.reverse_add_C | Mathlib.Algebra.Polynomial.Reverse | ∀ {R : Type u_1} [inst : Semiring R] (p : Polynomial R) (t : R),
(p + Polynomial.C t).reverse = p.reverse + Polynomial.C t * Polynomial.X ^ p.natDegree | true |
RingNorm.eq_zero_of_map_eq_zero' | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | ∀ {R : Type u_2} [inst : NonUnitalNonAssocRing R] (self : RingNorm R) (x : R), self.toFun x = 0 → x = 0 | true |
Lean.Parser.Tactic.pushCast | Init.Tactics | Lean.ParserDescr | true |
NonUnitalRingHom.codRestrict | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | {R : Type u} →
{S : Type v} →
[inst : NonUnitalNonAssocSemiring R] →
{F : Type u_1} →
[inst_1 : FunLike F R S] →
[inst_2 : NonUnitalNonAssocSemiring S] →
[NonUnitalRingHomClass F R S] →
{S' : Type u_2} →
[inst_4 : SetLike S' S] →
... | true |
String.instDecidableIsValidForSlice | Init.Data.String.Basic | {s : String.Slice} → {p : String.Pos.Raw} → Decidable (String.Pos.Raw.IsValidForSlice s p) | true |
Matrix.transpose_replicateCol | Mathlib.LinearAlgebra.Matrix.RowCol | ∀ {m : Type u_2} {α : Type v} {ι : Type u_6} (v : m → α), (Matrix.replicateCol ι v).transpose = Matrix.replicateRow ι v | true |
Prod.swap_eq_iff_eq_swap | Mathlib.Data.Prod.Basic | ∀ {α : Type u_1} {β : Type u_2} {x : α × β} {y : β × α}, x.swap = y ↔ x = y.swap | true |
Matrix.equiv_GL_linearindependent | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Card | {𝔽 : Type u_1} → [inst : Field 𝔽] → [Fintype 𝔽] → (n : ℕ) → GL (Fin n) 𝔽 ≃ { s // LinearIndependent 𝔽 s } | true |
dvd_sub_comm | Mathlib.Algebra.Ring.Divisibility.Basic | ∀ {α : Type u_1} [inst : NonUnitalRing α] {a b c : α}, a ∣ b - c ↔ a ∣ c - b | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.carry_succ._proof_1_4 | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} (i : ℕ) (x y : BitVec w) (c : Bool),
¬(2 * 2 ^ i ≤ x.toNat % 2 ^ i + (2 ^ i + y.toNat % 2 ^ i) + c.toNat ↔
2 ^ i ≤ x.toNat % 2 ^ i + y.toNat % 2 ^ i + c.toNat) →
False | false |
_private.Mathlib.Combinatorics.SetFamily.Shatter.0.Finset.card_le_card_shatterer._simp_1_9 | Mathlib.Combinatorics.SetFamily.Shatter | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | false |
HomotopicalAlgebra.CofibrantObject.HoCat.localizerMorphismResolution_functor | Mathlib.AlgebraicTopology.ModelCategory.CofibrantObjectHomotopy | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : HomotopicalAlgebra.ModelCategory C],
(HomotopicalAlgebra.CofibrantObject.HoCat.localizerMorphismResolution C).functor =
HomotopicalAlgebra.CofibrantObject.HoCat.resolution | true |
CategoryTheory.LocalizerMorphism.LeftResolution.op | Mathlib.CategoryTheory.Localization.Resolution | {C₁ : Type u_1} →
{C₂ : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
{Φ : CategoryTheory.LocalizerMorphism W₁ W₂} →
... | true |
ContMDiffOn.of_succ | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | true |
BoxIntegral.Prepartition.splitMany_insert | Mathlib.Analysis.BoxIntegral.Partition.Split | ∀ {ι : Type u_1} (I : BoxIntegral.Box ι) (s : Finset (ι × ℝ)) (p : ι × ℝ),
BoxIntegral.Prepartition.splitMany I (insert p s) =
BoxIntegral.Prepartition.splitMany I s ⊓ BoxIntegral.Prepartition.split I p.1 p.2 | true |
DilationEquiv.smulTorsor._proof_1 | Mathlib.Analysis.Normed.Affine.AddTorsor | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : NormedDivisionRing 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : Module 𝕜 E]
{P : Type u_3} [inst_3 : PseudoMetricSpace P] [inst_4 : NormedAddTorsor E P] (c : P) {k : 𝕜},
k ≠ 0 → ∀ (x : E), (k⁻¹ • fun x => x -ᵥ c) ((fun x => k • x +ᵥ c) x) = x | false |
continuousAt_pi | Mathlib.Topology.Constructions | ∀ {X : Type u} {ι : Type u_5} {A : ι → Type u_6} [inst : TopologicalSpace X] [T : (i : ι) → TopologicalSpace (A i)]
{f : X → (i : ι) → A i} {x : X}, ContinuousAt f x ↔ ∀ (i : ι), ContinuousAt (fun y => f y i) x | true |
Filter.Tendsto.inf_nhds | Mathlib.Topology.Order.Lattice | ∀ {L : Type u_1} [inst : TopologicalSpace L] {α : Type u_3} {l : Filter α} {f g : α → L} {x y : L} [inst_1 : Min L]
[ContinuousInf L],
Filter.Tendsto f l (nhds x) → Filter.Tendsto g l (nhds y) → Filter.Tendsto (fun i => f i ⊓ g i) l (nhds (x ⊓ y)) | true |
Lean.Parser.Tactic.tacticSeq1Indented | Lean.Parser.Term.Basic | Lean.Parser.Parser | true |
Order.PFilter.sInf_gc | Mathlib.Order.PFilter | ∀ {P : Type u_1} [inst : CompleteSemilatticeInf P],
GaloisConnection (fun x => OrderDual.toDual (Order.PFilter.principal x)) fun F => sInf ↑(OrderDual.ofDual F) | true |
_private.Lean.Meta.Sym.Simp.Forall.0.Lean.Meta.Sym.Simp.ToArrowResult._sizeOf_inst | Lean.Meta.Sym.Simp.Forall | SizeOf Lean.Meta.Sym.Simp.ToArrowResult✝ | false |
Lean.Elab.Tactic.Grind.saveTacticInfoForToken | Lean.Elab.Tactic.Grind.Basic | Lean.Syntax → Lean.Elab.Tactic.Grind.GrindTacticM Unit | true |
TestFunction.coe_sub | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_4}
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {n : ℕ∞} (f g : TestFunction Ω F n), ⇑(f - g) = ⇑f - ⇑g | true |
Rack.instDivInvMonoidEnvelGroup._proof_2 | Mathlib.Algebra.Quandle | ∀ (R : Type u_1) [inst : Rack R] (a b c : Rack.EnvelGroup R), a * b * c = a * (b * c) | false |
ContinuousLinearMap.prodₗᵢ | Mathlib.Analysis.Normed.Operator.Prod | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
{G : Type u_4} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup E] →
[inst_2 : SeminormedAddCommGroup F] →
[inst_3 : SeminormedAddCommGroup G] →
[inst_4 : NormedSpace 𝕜 E]... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.