name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ValuationSubring.unitsModPrincipalUnitsEquivResidueFieldUnits._proof_2 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] (A : ValuationSubring K),
Subgroup.comap A.unitGroup.subtype A.principalUnitGroup = A.unitGroupToResidueFieldUnits.ker | null | false |
isExtrFilter_dual_iff | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : Preorder β] {f : α → β} {l : Filter α} {a : α},
IsExtrFilter (⇑OrderDual.toDual ∘ f) l a ↔ IsExtrFilter f l a | null | true |
Int32.one_mul | Init.Data.SInt.Lemmas | ∀ (a : Int32), 1 * a = a | null | true |
BddLat.hasForgetToBddOrd._proof_1 | Mathlib.Order.Category.BddLat | ∀ (X : BddLat),
BddOrd.ofHom (BddLat.Hom.hom (CategoryTheory.CategoryStruct.id X)).toBoundedOrderHom =
CategoryTheory.CategoryStruct.id (BddOrd.of ↑X.toLat) | null | false |
AddHom.instAdd.eq_1 | Mathlib.Algebra.Group.Hom.Basic | ∀ {M : Type u_2} {N : Type u_3} [inst : Add M] [inst_1 : AddCommSemigroup N],
AddHom.instAdd = { add := fun f g => { toFun := fun m => f m + g m, map_add' := ⋯ } } | null | true |
CoalgCat.mk.noConfusion | Mathlib.Algebra.Category.CoalgCat.Basic | {R : Type u} →
{inst : CommRing R} →
{P : Sort u_1} →
{toModuleCat : ModuleCat R} →
{instCoalgebra : Coalgebra R ↑toModuleCat} →
{toModuleCat' : ModuleCat R} →
{instCoalgebra' : Coalgebra R ↑toModuleCat'} →
{ toModuleCat := toModuleCat, instCoalgebra := instCoalge... | null | false |
Prod.seminormedRing._proof_12 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} {β : Type u_1} [inst : SeminormedRing α] [inst_1 : SeminormedRing β] (n : ℕ), ↑(n + 1) = ↑n + 1 | null | false |
Nat.div_ne_zero_iff_of_dvd | Init.Data.Nat.Lemmas | ∀ {b a : ℕ}, b ∣ a → (a / b ≠ 0 ↔ a ≠ 0 ∧ b ≠ 0) | null | true |
Lean.Widget.instEmptyCollectionInteractiveGoals | Lean.Widget.InteractiveGoal | EmptyCollection Lean.Widget.InteractiveGoals | null | true |
CategoryTheory.Functor.Faithful.div_comp | Mathlib.CategoryTheory.Functor.FullyFaithful | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C E) [F.Faithful]
(G : CategoryTheory.Functor D E) [inst_4 : G.Faithful] (obj : C → D) (h_obj : ∀ (X : C), G... | null | true |
Filter.Realizer.comap._proof_1 | Mathlib.Data.Analysis.Filter | ∀ {α : Type u_3} {β : Type u_1} (m : α → β) {f : Filter β} (F : f.Realizer) (x x_1 : F.σ),
m ⁻¹' F.F.f (F.F.inf x x_1) ⊆ m ⁻¹' F.F.f x | null | false |
CategoryTheory.SmallObject.SuccStruct.extendToSucc.map._proof_6 | Mathlib.CategoryTheory.SmallObject.Iteration.ExtendToSucc | ∀ {J : Type u_1} [inst : LinearOrder J] [inst_1 : SuccOrder J] {j : J} (i₂ : J) (h₁ : i₂ ≤ j), ↑⟨i₂, h₁⟩ ≤ Order.succ j | null | false |
ModuleCat.Hom._sizeOf_1 | Mathlib.Algebra.Category.ModuleCat.Basic | {R : Type u} → {inst : Ring R} → {M N : ModuleCat R} → [SizeOf R] → M.Hom N → ℕ | null | false |
PseudoEpimorphismClass.recOn | Mathlib.Topology.Order.Hom.Esakia | {F : Type u_6} →
{α : Type u_7} →
{β : Type u_8} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
[inst_2 : FunLike F α β] →
{motive : PseudoEpimorphismClass F α β → Sort u} →
(t : PseudoEpimorphismClass F α β) →
([toRelHomClass : RelHomClass F (fun... | null | false |
Algebra.TensorProduct.uliftEquiv._proof_2 | Mathlib.RingTheory.TensorProduct.Maps | ∀ (R : Type u_1) (S : Type u_2) (A : Type u_3) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
[inst_3 : Semiring A] [inst_4 : Algebra R A] [inst_5 : Algebra S A] [IsScalarTower R S A],
SMulCommClass R S (ULift.{u_4, u_3} A) | null | false |
Batteries.BinomialHeap.Imp.Heap.foldM._unary | Batteries.Data.BinomialHeap.Basic | {m : Type u_1 → Type u_2} →
{α : Type u_3} →
{β : Type u_1} → [Monad m] → (α → α → Bool) → (β → α → m β) → (_ : Batteries.BinomialHeap.Imp.Heap α) ×' β → m β | `O(n log n)`. Monadic fold over the elements of a heap in increasing order,
by repeatedly pulling the minimum element out of the heap.
| false |
_private.Init.Data.Fin.Lemmas.0.Fin.reverseInduction_castSucc_aux._proof_1_4 | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (j : ℕ) (i : Fin n), ↑i < j + 1 → ¬↑i = j → ¬↑i < j → False | null | false |
CategoryTheory.Subgroupoid.obj_surjective_of_im_eq_top | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] {D : Type u_1} [inst_1 : CategoryTheory.Groupoid D]
(φ : CategoryTheory.Functor C D) (hφ : Function.Injective φ.obj),
CategoryTheory.Subgroupoid.im φ hφ = ⊤ → Function.Surjective φ.obj | null | true |
Subbimodule.toSubmodule._proof_1 | Mathlib.Algebra.Module.Bimodule | ∀ {R : Type u_4} {A : Type u_3} {B : Type u_2} {M : Type u_1} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : Semiring A] [inst_4 : Semiring B] [inst_5 : Module A M] [inst_6 : Module B M]
[inst_7 : Algebra R A] [inst_8 : Algebra R B] [inst_9 : IsScalarTower R A M] [inst_10 : IsSca... | null | false |
_private.Mathlib.Order.LatticeIntervals.0.Set.Iic.disjoint_iff._simp_1_1 | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b = ⊥) | null | false |
Pell.x_sub_y_dvd_pow | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a : ℕ} (a1 : 1 < a) (y n : ℕ), 2 * ↑a * ↑y - ↑y * ↑y - 1 ∣ Pell.yz a1 n * (↑a - ↑y) + ↑(y ^ n) - Pell.xz a1 n | null | true |
NNRat.coe_pow._simp_1 | Mathlib.Data.NNRat.Defs | ∀ (q : ℚ≥0) (n : ℕ), ↑q ^ n = ↑(q ^ n) | null | false |
_private.Mathlib.LinearAlgebra.Matrix.ToLin.0.LinearMap.toMatrix_basis_equiv._simp_1_1 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
Std.DTreeMap.Internal.Impl.link!._unary.induct_unfolding | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} (k : α) (v : β k)
(motive :
(_ : Std.DTreeMap.Internal.Impl α β) ×' Std.DTreeMap.Internal.Impl α β → Std.DTreeMap.Internal.Impl α β → Prop),
(∀ (r : Std.DTreeMap.Internal.Impl α β),
motive ⟨Std.DTreeMap.Internal.Impl.leaf, r⟩ (Std.DTreeMap.Internal.Impl.insertMin! k v r)) →... | null | false |
List.IsChain.backwards_cons_induction | Mathlib.Data.List.Chain | ∀ {α : Type u} {r : α → α → Prop} {a b : α} (p : α → Prop) (l : List α),
List.IsChain r (a :: l) → (a :: l).getLast ⋯ = b → (∀ ⦃x y : α⦄, r x y → p y → p x) → p b → ∀ i ∈ a :: l, p i | null | true |
NonUnitalAlgHom.Lmul._proof_4 | Mathlib.Analysis.Normed.Operator.Mul | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] (R : Type u_2) [inst_1 : NonUnitalSeminormedRing R]
[inst_2 : NormedSpace 𝕜 R], ContinuousConstSMul 𝕜 R | null | false |
Lean.pp.analyze.trustOfNat | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.Option Bool | null | true |
CategoryTheory.Pretopology.trivial._proof_2 | Mathlib.CategoryTheory.Sites.Pretopology | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] ⦃X : C⦄ (S : CategoryTheory.Presieve X)
(Ti : ⦃Y : C⦄ → (f : Y ⟶ X) → S f → CategoryTheory.Presieve Y),
S ∈ {S | ∃ Y f, ∃ (_ : CategoryTheory.IsIso f), S = CategoryTheory.Presieve.singleton f} →
(∀ ⦃Y : C⦄ (f : Y ⟶ X) (H : S f),
Ti f H ∈ {S ... | null | false |
Std.Ric.le_upper_of_mem | Init.Data.Range.Polymorphic.Basic | ∀ {α : Type u} {r : Std.Ric α} {a : α} [inst : LE α] [LT α], a ∈ r → a ≤ r.upper | null | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.Methods.toMethodsRef.unsafe_impl_2 | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.Methods → Lean.Meta.Grind.MethodsRef | null | true |
Module.Relations.solutionFinsupp._proof_1 | Mathlib.Algebra.Module.Presentation.Free | ∀ {A : Type u_1} [inst : Ring A] (relations : Module.Relations A) [IsEmpty relations.R] (r : relations.R),
(Finsupp.linearCombination A fun g => fun₀ | g => 1) (relations.relation r) = 0 | null | false |
IsSeparatedMap.pullback | Mathlib.Topology.SeparatedMap | ∀ {X : Type u_1} {Y : Sort u_2} {A : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace A] {f : X → Y},
IsSeparatedMap f → ∀ (g : A → Y), IsSeparatedMap Function.Pullback.snd | null | true |
_private.Lean.Meta.LazyDiscrTree.0.Lean.Meta.LazyDiscrTree.blacklistInsertion._sparseCasesOn_1 | Lean.Meta.LazyDiscrTree | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
UniformOnFun.instPseudoEMetricSpace._proof_4 | Mathlib.Topology.MetricSpace.UniformConvergence | ∀ {α : Type u_2} {β : Type u_1} {𝔖 : Set (Set α)} [inst : PseudoEMetricSpace β] [inst_1 : Finite ↑𝔖]
(f₁ f₂ f₃ : UniformOnFun α β 𝔖), edist f₁ f₃ ≤ edist f₁ f₂ + edist f₂ f₃ | null | false |
Polynomial.comp.eq_1 | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} [inst : Semiring R] (p q : Polynomial R), p.comp q = Polynomial.eval₂ Polynomial.C q p | null | true |
Lean.mkAndN._sunfold | Lean.Expr | List Lean.Expr → Lean.Expr | null | false |
Int8.toInt.eq_1 | Init.Data.SInt.Lemmas | ∀ (i : Int8), i.toInt = i.toBitVec.toInt | null | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms.0.SimplexCategoryGenRel.IsAdmissible.cons._proof_1_2 | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | ∀ {m a : ℕ}, a ≤ m → SimplexCategoryGenRel.IsAdmissible m [a] | null | false |
CategoryTheory.MorphismProperty.epimorphisms.iff._simp_1 | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.MorphismProperty.epimorphisms C f = CategoryTheory.Epi f | null | false |
_private.Mathlib.RingTheory.Coalgebra.CoassocSimps.0.CoassocSimps.«_aux_Mathlib_RingTheory_Coalgebra_CoassocSimps___delab_app__private_Mathlib_RingTheory_Coalgebra_CoassocSimps_0_CoassocSimps_termρ⁻¹_1» | Mathlib.RingTheory.Coalgebra.CoassocSimps | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
OrderRingHom.apply_eq_self | Mathlib.Algebra.Order.Archimedean.Hom | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] [Archimedean α] (f : α →+*o α)
(x : α), f x = x | null | true |
CategoryTheory.ShortComplex.rightHomology_ext | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasRightHomology] {A : C} (f₁ f₂ : A ⟶ S.rightHomology),
CategoryTheory.CategoryStruct.comp f₁ S.rightHomologyι = CategoryTheory.CategoryStruct.comp f₂ S... | null | true |
seqCompactSpace_iff | Mathlib.Topology.Defs.Sequences | ∀ (X : Type u_1) [inst : TopologicalSpace X], SeqCompactSpace X ↔ IsSeqCompact Set.univ | null | true |
SheafOfModules.evaluationPreservesLimitsOfSize | Mathlib.Algebra.Category.ModuleCat.Sheaf.Limits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
(R : CategoryTheory.Sheaf J RingCat) (X : Cᵒᵖ),
CategoryTheory.Limits.PreservesLimitsOfSize.{v₂, v, max u₁ v, v, max (max (max u u₁) (v + 1)) v₁, max u (v + 1)}
(SheafOfModules.evaluation R X) | null | true |
Lean.Meta.Grind.Arith.CommRing.DiseqCnstr.noConfusion | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | {P : Sort u} →
{t t' : Lean.Meta.Grind.Arith.CommRing.DiseqCnstr} →
t = t' → Lean.Meta.Grind.Arith.CommRing.DiseqCnstr.noConfusionType P t t' | null | false |
RelIso.emptySumLex_apply | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} (r : α → α → Prop) (s : β → β → Prop) [inst : IsEmpty α] (a : α ⊕ β),
(RelIso.emptySumLex r s) a = (Equiv.sumEmpty β α) a.swap | null | true |
_private.Mathlib.Probability.Moments.Variance.0.ProbabilityTheory.evariance_eq_zero_iff._simp_1_2 | Mathlib.Probability.Moments.Variance | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
Lean.JsonRpc.instInhabitedMessageDirection | Lean.Data.JsonRpc | Inhabited Lean.JsonRpc.MessageDirection | null | true |
Real.HolderConjugate.div_conj_eq_sub_one | Mathlib.Data.Real.ConjExponents | ∀ {p q : ℝ}, p.HolderConjugate q → p / q = p - 1 | null | true |
cfcₙ_smul._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
NonUnitalCommCStarAlgebra.recOn | Mathlib.Analysis.CStarAlgebra.Classes | {A : Type u_1} →
{motive : NonUnitalCommCStarAlgebra A → Sort u} →
(t : NonUnitalCommCStarAlgebra A) →
([toNonUnitalNormedCommRing : NonUnitalNormedCommRing A] →
[toStarRing : StarRing A] →
[toCompleteSpace : CompleteSpace A] →
[toCStarRing : CStarRing A] →
... | null | false |
IsDedekindDomain.HeightOneSpectrum.adicAbv._proof_1 | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] {K : Type u_2} [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R) {b : NNReal}
(hb : 1 < b) (x : K), 0 ≤ ↑(v.adicAbvDef hb x) | null | false |
IntermediateField.relrank_dvd_of_le_left | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A B : IntermediateField F E}
(C : IntermediateField F E), A ≤ B → B.relrank C ∣ A.relrank C | null | true |
AffineMap.pi_ext_nonempty | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_2} {V2 : Type u_5} {P2 : Type u_6} [inst : Ring k] [inst_1 : AddCommGroup V2] [inst_2 : AddTorsor V2 P2]
[inst_3 : Module k V2] {ι : Type u_9} {φv : ι → Type u_10} [inst_4 : (i : ι) → AddCommGroup (φv i)]
[inst_5 : (i : ι) → Module k (φv i)] [Finite ι] [inst_7 : DecidableEq ι] {f g : ((i : ι) → φv i) ... | Two affine maps from a Pi-type of modules `(i : ι) → φv i` are equal if they are equal in their
operation on `Pi.single` and `ι` is nonempty. Analogous to `LinearMap.pi_ext`. See also
`pi_ext_zero`, which instead of `Nonempty ι` requires agreement at 0. | true |
Nat.dvd_of_mem_primeFactorsList | Mathlib.Data.Nat.Factors | ∀ {n p : ℕ}, p ∈ n.primeFactorsList → p ∣ n | null | true |
Std.DHashMap.Raw.Const.equiv_of_beq | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.DHashMap.Raw α fun x => β} [LawfulBEq α]
[inst_3 : BEq β] [LawfulBEq β], m₁.WF → m₂.WF → Std.DHashMap.Raw.Const.beq m₁ m₂ = true → m₁.Equiv m₂ | null | true |
RootPairing.rec | Mathlib.LinearAlgebra.RootSystem.Defs | {ι : 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] →
{motive : RootPairing ι R M N → Sort... | null | false |
MeasurableEquiv.prodCongr.eq_1 | Mathlib.MeasureTheory.Measure.Haar.InnerProductSpace | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
[inst_2 : MeasurableSpace γ] [inst_3 : MeasurableSpace δ] (ab : α ≃ᵐ β) (cd : γ ≃ᵐ δ),
ab.prodCongr cd = { toEquiv := ab.prodCongr cd.toEquiv, measurable_toFun := ⋯, measurable_invFun := ⋯ } | null | true |
RingCon.instCompleteLattice._proof_2 | Mathlib.RingTheory.Congruence.Basic | ∀ {R : Type u_1} [inst : Add R] [inst_1 : Mul R] (c d : RingCon R) {w x y z : R},
(c.toSetoid ⊓ d.toSetoid) w x →
(c.toSetoid ⊓ d.toSetoid) y z → c.toSetoid (w * y) (x * z) ∧ d.toSetoid (w * y) (x * z) | null | false |
_private.Mathlib.LinearAlgebra.Finsupp.Span.0.Finsupp.iInf_ker_lapply_le_bot._simp_1_2 | Mathlib.LinearAlgebra.Finsupp.Span | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Sort u_4}
(p : ι → Submodule R M) {x : M}, (x ∈ ⨅ i, p i) = ∀ (i : ι), x ∈ p i | null | false |
SSet.IsStrictSegal.mk | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ {X : SSet}, (∀ (n : ℕ), Function.Bijective (X.spine n)) → X.IsStrictSegal | null | true |
SSet.StrictSegalCore.concat | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | {X : SSet} →
{n : ℕ} →
X.StrictSegalCore n →
(x : X.obj (Opposite.op { len := 1 })) →
(s : X.obj (Opposite.op { len := n })) →
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.SimplicialObject.δ X 0)) x =
(CategoryTheory.ConcreteCategory.hom (X.map ({ len := 0 }.const { l... | Map which produces an `n + 1`-simplex from a `1`-simplex and an `n`-simplex when
the target vertex of the `1`-simplex equals the zeroth simplex of the `n`-simplex. | true |
Std.LinearPreorderPackage.le_total | Init.Data.Order.PackageFactories | ∀ {α : Type u} [self : Std.LinearPreorderPackage α] (a b : α), a ≤ b ∨ b ≤ a | null | true |
_private.Mathlib.Algebra.Lie.Semisimple.Basic.0.LieAlgebra.IsSemisimple.isSimple_of_isAtom._simp_1_15 | Mathlib.Algebra.Lie.Semisimple.Basic | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.Context.rec | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | {motive : Lean.PrettyPrinter.Delaborator.TopDownAnalyze.Context → Sort u} →
((knowsType knowsLevel inBottomUp parentIsApp : Bool) →
(subExpr : Lean.SubExpr) →
motive
{ knowsType := knowsType, knowsLevel := knowsLevel, inBottomUp := inBottomUp, parentIsApp := parentIsApp,
subExpr :=... | null | false |
Complex.norm_log_one_add_sub_self_le | Mathlib.Analysis.SpecialFunctions.Complex.LogBounds | ∀ {z : ℂ}, ‖z‖ < 1 → ‖Complex.log (1 + z) - z‖ ≤ ‖z‖ ^ 2 * (1 - ‖z‖)⁻¹ / 2 | The difference `log (1+z) - z` is bounded by `‖z‖^2/(2*(1-‖z‖))` when `‖z‖ < 1`. | true |
AddCommute.addUnits_neg_right | Mathlib.Algebra.Group.Commute.Units | ∀ {M : Type u_1} [inst : AddMonoid M] {a : M} {u : AddUnits M}, AddCommute a ↑u → AddCommute a ↑(-u) | null | true |
_private.Lean.Elab.BuiltinCommand.0.Lean.Elab.Command.elabSection._regBuiltin.Lean.Elab.Command.elabSection.declRange_3 | Lean.Elab.BuiltinCommand | IO Unit | null | false |
_private.Mathlib.FieldTheory.KrullTopology.0.IntermediateField.map_fixingSubgroup._simp_1_1 | Mathlib.FieldTheory.KrullTopology | ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] {K : Subgroup N} {f : G →* N} {x : G},
(x ∈ Subgroup.comap f K) = (f x ∈ K) | null | false |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.DTreeMap.Internal.Cell.Const.alter.match_1.eq_2 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u_2} {β : Type u_1} (motive : Option ((_ : α) × β) → Sort u_3) (fst : α) (v' : β) (h_1 : Unit → motive none)
(h_2 : (fst : α) → (v' : β) → motive (some ⟨fst, v'⟩)),
(match some ⟨fst, v'⟩ with
| none => h_1 ()
| some ⟨fst, v'⟩ => h_2 fst v') =
h_2 fst v' | null | true |
Aesop.Nanos.instDecidableRelLt | Aesop.Nanos | DecidableRel fun x1 x2 => x1 < x2 | null | true |
_private.Mathlib.Tactic.Linter.UnusedTactic.0.Mathlib.Linter.UnusedTactic.eraseUsedTactics | Mathlib.Tactic.Linter.UnusedTactic | Std.HashSet Lean.SyntaxNodeKind → Lean.Elab.InfoTree → Mathlib.Linter.UnusedTactic.M✝ Unit | Search for tactic executions in the info tree and remove the syntax of the tactics that
changed something. | true |
Bornology.IsBounded.snd_of_prod | Mathlib.Topology.Bornology.Constructions | ∀ {α : Type u_1} {β : Type u_2} [inst : Bornology α] [inst_1 : Bornology β] {s : Set α} {t : Set β},
Bornology.IsBounded (s ×ˢ t) → s.Nonempty → Bornology.IsBounded t | null | true |
Equiv.boolEquivPUnitSumPUnit._proof_1 | Mathlib.Logic.Equiv.Sum | ∀ (b : Bool),
Sum.elim (fun x => false) (fun x => true) ((fun b => Bool.casesOn b (Sum.inl PUnit.unit) (Sum.inr PUnit.unit)) b) = b | null | false |
Antivary.of_inv_right | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : CommGroup β] [inst_2 : PartialOrder β]
[IsOrderedMonoid β] {f : ι → α} {g : ι → β}, Antivary f g⁻¹ → Monovary f g | **Alias** of the forward direction of `antivary_inv_right`. | true |
continuous_sigmaMk | Mathlib.Topology.Constructions | ∀ {ι : Type u_5} {σ : ι → Type u_7} [inst : (i : ι) → TopologicalSpace (σ i)] {i : ι}, Continuous (Sigma.mk i) | null | true |
CategoryTheory.PreservesPullbacksOfInclusions.rec | Mathlib.CategoryTheory.Extensive | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{F : CategoryTheory.Functor C D} →
[inst_2 : CategoryTheory.Limits.HasBinaryCoproducts C] →
{motive : CategoryTheory.PreservesPullbacksOfInclusion... | null | false |
PadicInt.toZMod._proof_2 | Mathlib.NumberTheory.Padics.RingHoms | ∀ {p : ℕ} [hp_prime : Fact (Nat.Prime p)] (x : ℤ_[p]) (a b : ℕ),
x - ↑a ∈ Ideal.span {↑p} → x - ↑b ∈ Ideal.span {↑p} → ↑a = ↑b | null | false |
_private.Mathlib.Analysis.Convex.Between.0.sbtw_neg_iff._simp_1_1 | Mathlib.Analysis.Convex.Between | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a : G), -a = 0 - a | null | false |
RatFunc.liftRingHom_ofFractionRing_algebraMap | Mathlib.FieldTheory.RatFunc.Basic | ∀ {L : Type u_2} {R : Type u_3} [inst : Field L] [inst_1 : CommRing R] (φ : Polynomial R →+* L)
(hφ : nonZeroDivisors (Polynomial R) ≤ Submonoid.comap φ (nonZeroDivisors L)) (x : Polynomial R),
(RatFunc.liftRingHom φ hφ) { toFractionRing := (algebraMap (Polynomial R) (FractionRing (Polynomial R))) x } = φ x | null | true |
Std.Sat.AIG.mkGateCached.go._proof_1 | Std.Sat.AIG.Cached | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] (decls : Array (Std.Sat.AIG.Decl α))
(cache : Std.Sat.AIG.Cache α decls) (hdag : Std.Sat.AIG.IsDAG α decls) (hzero : 0 < decls.size)
(hconst : decls[0] = Std.Sat.AIG.Decl.false)
(input : { decls := decls, cache := cache, hdag := hdag, hzero := hzero, hcons... | null | false |
_private.Mathlib.RingTheory.Algebraic.Defs.0.Algebra.isAlgebraic_iff._simp_1_3 | Mathlib.RingTheory.Algebraic.Defs | ∀ {p : Prop} {q : p → Prop} (h : p), (∀ (h' : p), q h') = q h | null | false |
List.card_toFinset | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α), l.toFinset.card = l.dedup.length | null | true |
WittVector.IsocrystalHom._sizeOf_1 | Mathlib.RingTheory.WittVector.Isocrystal | {p : ℕ} →
{inst : Fact (Nat.Prime p)} →
{k : Type u_1} →
{inst_1 : CommRing k} →
{inst_2 : CharP k p} →
{inst_3 : PerfectRing k p} →
{V : Type u_2} →
{inst_4 : AddCommGroup V} →
{inst_5 : WittVector.Isocrystal p k V} →
{V₂ : Type ... | null | false |
Std.Http.Method.rebind.sizeOf_spec | Std.Http.Data.Method | sizeOf Std.Http.Method.rebind = 1 | null | true |
Vector.swap._auto_3 | Init.Data.Vector.Basic | Lean.Syntax | null | false |
WithVal.instNumberField | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {R : Type u_1} {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : Field R] (v : Valuation R Γ₀)
[NumberField R], NumberField (WithVal v) | null | true |
Polynomial.Monic.eq_one_of_isUnit | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.Monic → IsUnit p → p = 1 | null | true |
Matroid.emptyOn_isBase_iff._simp_1 | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {B : Set α}, (Matroid.emptyOn α).IsBase B = (B = ∅) | null | false |
Lean.Meta.Grind.Arith.CommRing.EqCnstr.simplify | Lean.Meta.Tactic.Grind.Arith.CommRing.EqCnstr | Lean.Meta.Grind.Arith.CommRing.EqCnstr → Lean.Meta.Grind.Arith.CommRing.RingM Lean.Meta.Grind.Arith.CommRing.EqCnstr | Simplify the given equation constraint using the current basis. | true |
Topology.IsEmbedding.comp | Mathlib.Topology.Maps.Basic | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {f : X → Y} {g : Y → Z} [inst : TopologicalSpace X]
[inst_1 : TopologicalSpace Y] [inst_2 : TopologicalSpace Z],
Topology.IsEmbedding g → Topology.IsEmbedding f → Topology.IsEmbedding (g ∘ f) | null | true |
IsOpen.stronglyLocallyContractibleSpace | Mathlib.Topology.Homotopy.LocallyContractible | ∀ {X : Type u_1} [inst : TopologicalSpace X] [StronglyLocallyContractibleSpace X] {U : Set X},
IsOpen U → StronglyLocallyContractibleSpace ↑U | Open subsets of strongly locally contractible spaces are strongly locally contractible. | true |
ModuleCat.CoextendScalars.map' | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | {R : Type u₁} →
{S : Type u₂} →
[inst : Ring R] →
[inst_1 : Ring S] →
(f : R →+* S) →
{M M' : ModuleCat R} → (M ⟶ M') → (ModuleCat.CoextendScalars.obj' f M ⟶ ModuleCat.CoextendScalars.obj' f M') | If `M, M'` are `R`-modules, then any `R`-linear map `g : M ⟶ M'` induces an `S`-linear map
`(S →ₗ[R] M) ⟶ (S →ₗ[R] M')` defined by `h ↦ g ∘ h` | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.getMatchEqCondForAux | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums | Lean.Name → Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind → Lean.MetaM Lean.Name | Generate a theorem that translates `.match_x` applications on enum inductives to chains of `cond`,
assuming that it is a supported kind of match, see `matchIsSupported` for the currently available
variants.
| true |
Equiv.prodEmbeddingDisjointEquivSigmaEmbeddingRestricted._proof_1 | Mathlib.Logic.Equiv.Embedding | ∀ {α : Type u_3} {β : Type u_1} {γ : Type u_2} (a : α ↪ γ),
(fun b => Disjoint (Set.range ⇑a) (Set.range ⇑b)) = fun f => ∀ (a_1 : β), f a_1 ∈ (Set.range ⇑a)ᶜ | null | false |
cfc_star_id | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : TopologicalSpace A] [inst_6 : Ring A]
[inst_7 : StarRing A] [inst_8 : Algebra R A] [instCFC : ContinuousFunctionalCalculus R ... | null | true |
Ordinal.lt_one_iff_zero | Mathlib.SetTheory.Ordinal.Basic | ∀ {a : Ordinal.{u_1}}, a < 1 ↔ a = 0 | null | true |
_private.Mathlib.Logic.Equiv.Prod.0.Equiv.piEquivPiSubtypeProd._proof_7 | Mathlib.Logic.Equiv.Prod | ∀ {α : Type u_2} (p : α → Prop) (β : α → Type u_1) [inst : DecidablePred p] (f : (i : { x // p x }) → β ↑i)
(g : (i : { x // ¬p x }) → β ↑i),
(fun x => if h : p ↑x then (f, g).1 ⟨↑x, h⟩ else (f, g).2 ⟨↑x, h⟩, fun x =>
if h : p ↑x then (f, g).1 ⟨↑x, h⟩ else (f, g).2 ⟨↑x, h⟩).1 =
(f, g).1 | null | false |
_private.Mathlib.Order.RelSeries.0.RelSeries.append_assoc._simp_1_1 | Mathlib.Order.RelSeries | ∀ {m k n : ℕ}, (m + n = k + n) = (m = k) | null | false |
Function.Surjective.distribMulActionLeft | Mathlib.Algebra.GroupWithZero.Action.End | {R : Type u_6} →
{S : Type u_7} →
{M : Type u_8} →
[inst : Monoid R] →
[inst_1 : AddMonoid M] →
[inst_2 : DistribMulAction R M] →
[inst_3 : Monoid S] →
[inst_4 : SMul S M] →
(f : R →* S) → Function.Surjective ⇑f → (∀ (c : R) (x : M), f c • x = c • ... | Push forward the action of `R` on `M` along a compatible surjective map `f : R →* S`.
See also `Function.Surjective.mulActionLeft` and `Function.Surjective.moduleLeft`.
| true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.