name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
normalize_eq_zero | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : MonoidWithZero α] [inst_1 : NormalizationMonoid α] {x : α}, normalize x = 0 ↔ x = 0 | null | true |
Finpartition.IsEquipartition.card_interedges_sparsePairs_le' | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | ∀ {α : Type u_1} {𝕜 : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : DecidableEq α] {A : Finset α} {P : Finpartition A} {G : SimpleGraph α} [inst_4 : DecidableRel G.Adj]
{ε : 𝕜},
P.IsEquipartition →
0 ≤ ε →
↑((P.sparsePairs G ε).biUnion fun x =>
... | null | true |
Int.instConditionallyCompleteLinearOrder._proof_11 | Mathlib.Order.Int.ConditionallyCompleteOrder | ∀ (s : Set ℤ), s.Nonempty ∧ BddBelow s → BddBelow s | null | false |
Lean.Grind.Order.le_eq_true_of_lt | Init.Grind.Order | ∀ {α : Type u_1} [inst : LE α] [inst_1 : LT α] [Std.LawfulOrderLT α] {a b : α}, a < b → (a ≤ b) = True | null | true |
_private.Lean.Util.PPExt.0.Lean.ppTerm.match_1 | Lean.Util.PPExt | (motive : Except IO.Error Std.Format → Sort u_1) →
(__do_lift : Except IO.Error Std.Format) →
((fmt : Std.Format) → motive (Except.ok fmt)) → ((ex : IO.Error) → motive (Except.error ex)) → motive __do_lift | null | false |
Mathlib.Tactic.LinearCombination.smul_lt_const | Mathlib.Tactic.LinearCombination.Lemmas | ∀ {α : Type u_1} {K : Type u_2} {t s : K} [inst : Ring K] [inst_1 : PartialOrder K] [IsOrderedRing K]
[inst_3 : AddCommGroup α] [inst_4 : PartialOrder α] [IsOrderedAddMonoid α] [inst_6 : Module K α]
[IsStrictOrderedModule K α], t < s → ∀ {a : α}, 0 < a → t • a < s • a | null | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft.0.Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastShiftLeft._simp_1_3 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft | ∀ {p : Prop} {x : Decidable p}, (decide p = false) = ¬p | null | false |
CongruenceSubgroup.exists_Gamma_le_conj' | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | ∀ (g : GL (Fin 2) ℚ) (M : ℕ) [NeZero M],
∃ N,
N ≠ 0 ∧
ConjAct.toConjAct ((Matrix.GeneralLinearGroup.map (Rat.castHom ℝ)) g) •
Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ) (CongruenceSubgroup.Gamma N) ≤
Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ) (CongruenceSubgroup.Gamma M) | For any `g ∈ GL(2, ℚ)` and `M ≠ 0`, there exists `N` such that `g Γ(N) g⁻¹ ≤ Γ(M)`. | true |
CategoryTheory.Functor.initial_const_initial | Mathlib.CategoryTheory.Filtered.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[CategoryTheory.IsCofiltered C] [inst_3 : CategoryTheory.Limits.HasInitial D],
((CategoryTheory.Functor.const C).obj (⊥_ D)).Initial | The inclusion of the initial object is initial. | true |
Std.Tactic.BVDecide.BVExpr.bitblast.go._proof_5 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | ∀ (w : ℕ) (aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (lhs : aig.RefVec w)
(aig_1 : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (rhs : aig_1.RefVec w)
(hraig : aig.decls.size ≤ { aig := aig_1, vec := rhs }.aig.decls.size),
(↑⟨{ aig := aig_1, vec := rhs }, hraig⟩).aig.decls.size ≤
(Std.Tactic.BVDecide.BVExpr.bitb... | null | false |
ZFSet.Nonempty.eq_1 | Mathlib.SetTheory.ZFC.Basic | ∀ (u : ZFSet.{u}), u.Nonempty = (↑u).Nonempty | null | true |
MvPolynomial.totalDegree_pow | Mathlib.Algebra.MvPolynomial.Degrees | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] (a : MvPolynomial σ R) (n : ℕ),
(a ^ n).totalDegree ≤ n * a.totalDegree | null | true |
OpenAddSubgroup.instSemilatticeInfOpenAddSubgroup | Mathlib.Topology.Algebra.OpenSubgroup | {G : Type u_1} → [inst : AddGroup G] → [inst_1 : TopologicalSpace G] → SemilatticeInf (OpenAddSubgroup G) | null | true |
directedOn_ge_Icc | Mathlib.Order.Interval.Set.Image | ∀ {α : Type u_1} [inst : Preorder α] (a b : α), DirectedOn (fun x1 x2 => x2 ≤ x1) (Set.Icc a b) | null | true |
MulAction.mem_orbit_self | Mathlib.GroupTheory.GroupAction.Defs | ∀ {M : Type u_1} {α : Type u_3} [inst : Monoid M] [inst_1 : MulAction M α] (a : α), a ∈ MulAction.orbit M a | null | true |
_private.Init.Data.Array.MapIdx.0.Array.mapIdx_eq_singleton_iff._simp_1_1 | Init.Data.Array.MapIdx | ∀ {α : Type u_1} {β : Type u_2} {l : List α} {f : ℕ → α → β} {b : β}, (List.mapIdx f l = [b]) = ∃ a, l = [a] ∧ f 0 a = b | null | false |
BiheytingHom.map_sdiff' | Mathlib.Order.Heyting.Hom | ∀ {α : Type u_6} {β : Type u_7} [inst : BiheytingAlgebra α] [inst_1 : BiheytingAlgebra β] (self : BiheytingHom α β)
(a b : α), self.toFun (a \ b) = self.toFun a \ self.toFun b | The proposition that a bi-Heyting homomorphism preserves the difference operation. | true |
Array.toListRev_iterFromIdx | Std.Data.Iterators.Lemmas.Producers.Array | ∀ {β : Type w} {array : Array β} {pos : ℕ}, (array.iterFromIdx pos).toListRev = (List.drop pos array.toList).reverse | null | true |
QuotientGroup.preimageMkEquivSubgroupProdSet._proof_5 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] (s : Subgroup α) (t : Set (α ⧸ s)) (a : ↥s × ↑t), ↑(Quotient.out ↑a.2 * ↑a.1) ∈ t | null | false |
_private.Mathlib.Analysis.Normed.Module.FiniteDimension.0.LinearIndependent.eventually._simp_1_1 | Mathlib.Analysis.Normed.Module.FiniteDimension | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {v : ι → M} [inst : Ring R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : Fintype ι] [inst_4 : DecidableEq ι],
LinearIndependent R v = (((LinearMap.lsum R (fun x => R) ℕ) fun i => LinearMap.id.smulRight (v i)).ker = ⊥) | null | false |
_private.Mathlib.Data.Finsupp.Order.0.Finsupp.subset_support_tsub._simp_1_1 | Mathlib.Data.Finsupp.Order | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ | null | false |
_private.Std.Time.Format.DateFormat.0.Std.Time.DateFormatSymbols.enUS._proof_6 | Std.Time.Format.DateFormat | #["M", "T", "W", "T", "F", "S", "S"].size = 7 | null | false |
Aesop.withAesopTraceNode | Aesop.Tracing | {m : Type → Type} →
{ε : Type} →
[Monad m] →
[Lean.MonadTrace m] →
[MonadLiftT BaseIO m] →
[Lean.MonadRef m] →
[Lean.AddMessageContext m] →
[Lean.MonadOptions m] →
[Lean.MonadAlwaysExcept ε m] →
{α : Type} →
[L... | null | true |
IsSemiprimaryRing.mk._flat_ctor | Mathlib.RingTheory.Jacobson.Semiprimary | ∀ {R : Type u_1} [inst : Ring R],
IsSemisimpleRing (R ⧸ Ring.jacobson R) → IsNilpotent (Ring.jacobson R) → IsSemiprimaryRing R | null | false |
_private.Mathlib.GroupTheory.CosetCover.0.Subgroup.exists_finiteIndex_of_leftCoset_cover_aux.match_1_3 | Mathlib.GroupTheory.CosetCover | ∀ {G : Type u_1} [inst : Group G] {ι : Type u_2} {H : ι → Subgroup G} {g : ι → G} {s : Finset ι} (j : ι)
(motive : (∃ x, ∀ i ∈ s, H i = H j → ↑(g i) ≠ ↑x) → Prop) (x : ∃ x, ∀ i ∈ s, H i = H j → ↑(g i) ≠ ↑x),
(∀ (x : G) (hx : ∀ i ∈ s, H i = H j → ↑(g i) ≠ ↑x), motive ⋯) → motive x | null | false |
Int.dvd_of_tmod_eq_zero | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, b.tmod a = 0 → a ∣ b | null | true |
Equiv.restrictPreimageFinset_apply_coe | Mathlib.Data.Finset.Preimage | ∀ {α : Type u} {β : Type v} (e : α ≃ β) (s : Finset β) (a : ↥(s.preimage ⇑e ⋯)),
↑((e.restrictPreimageFinset s) a) = e ↑a | null | true |
Real.rpow_add_le_add_rpow | Mathlib.Analysis.MeanInequalitiesPow | ∀ {p a b : ℝ}, 0 ≤ a → 0 ≤ b → 0 ≤ p → p ≤ 1 → (a + b) ^ p ≤ a ^ p + b ^ p | null | true |
Lean.Meta.Grind.NormalizePattern.State.bvarsFound._default | Lean.Meta.Tactic.Grind.EMatchTheorem | Std.HashSet ℕ | null | false |
Filter.map_mul_right_nhdsGT | Mathlib.Topology.Algebra.Group.Order | ∀ {H : Type u_1} [inst : TopologicalSpace H] [inst_1 : CommGroup H] [inst_2 : PartialOrder H] [IsOrderedMonoid H]
[ContinuousMul H] {c a : H},
Filter.map (fun x => x * c) (nhdsWithin a (Set.Ioi a)) = nhdsWithin (a * c) (Set.Ioi (a * c)) | null | true |
Polynomial.quotientSpanCXSubCXSubCAlgEquiv._proof_5 | Mathlib.RingTheory.Polynomial.Quotient | ∀ {R : Type u_1} [inst : CommRing R], IsScalarTower R (Polynomial R) (Polynomial R) | null | false |
Set.fintypeOfFintypeImage._proof_1 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u_1} {β : Type u_2} (s : Set α) {f : α → β} {g : β → Option α} (I : Function.IsPartialInv f g)
[inst : Fintype ↑(f '' s)] (x : α), x ∈ { val := Multiset.filterMap g (f '' s).toFinset.val, nodup := ⋯ } ↔ x ∈ s | null | false |
Prod.instOrderSupSet.eq_1 | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : OrderSupSet α] [inst_2 : Preorder β]
[inst_3 : OrderSupSet β], Prod.instOrderSupSet = { toSupSet := Prod.supSet α β, isLUB_sSup_of_isLUB := ⋯ } | null | true |
_private.Init.Data.Order.Factories.0.Std.LawfulOrderInf.of_lt._simp_1_2 | Init.Data.Order.Factories | ∀ {a b : Prop} [Decidable a] [Decidable b], (¬a ↔ ¬b) = (a ↔ b) | null | false |
Turing.TM2to1.Λ'.go.noConfusion | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{Λ : Type u_3} →
{σ : Type u_4} →
{P : Sort u} →
{k : K} →
{a : Turing.TM2to1.StAct K Γ σ k} →
{a_1 : Turing.TM2.Stmt Γ Λ σ} →
{k' : K} →
{a' : Turing.TM2to1.StAct K Γ σ k'} →
... | null | false |
CategoryTheory.CatEnrichedOrdinary.Hom.recOn | Mathlib.CategoryTheory.Bicategory.CatEnriched | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.EnrichedOrdinaryCategory CategoryTheory.Cat C] →
{X Y : CategoryTheory.CatEnrichedOrdinary C} →
{f g : X ⟶ Y} →
{motive : CategoryTheory.CatEnrichedOrdinary.Hom f g → Sort u_1} →
(t : CategoryTh... | null | false |
pow_left_strictMono | Mathlib.Algebra.Order.Monoid.Unbundled.Pow | ∀ {M : Type u_3} [inst : Monoid M] [inst_1 : Preorder M] [MulLeftStrictMono M] [MulRightStrictMono M] {n : ℕ},
n ≠ 0 → StrictMono fun x => x ^ n | See also `pow_left_strictMonoOn₀`. | true |
CategoryTheory.Limits.WeakLimitCone.mk.injEq | Mathlib.CategoryTheory.Limits.WeakLimits.Basic | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} J] {C : Type u_3}
[inst_1 : CategoryTheory.Category.{v_3, u_3} C] {F : CategoryTheory.Functor J C} (cone : CategoryTheory.Limits.Cone F)
(isWeakLimit : CategoryTheory.Limits.IsWeakLimit cone) (cone_1 : CategoryTheory.Limits.Cone F)
(isWeakLimit_1 : Categ... | null | true |
MeasureTheory.integrableOn_image_iff_integrableOn_deriv_smul_of_monotoneOn | Mathlib.MeasureTheory.Function.JacobianOneDim | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] {s : Set ℝ} {f f' : ℝ → ℝ},
MeasurableSet s →
(∀ x ∈ s, HasDerivWithinAt f (f' x) s x) →
MonotoneOn f s →
∀ (g : ℝ → F),
MeasureTheory.IntegrableOn g (f '' s) MeasureTheory.volume ↔
MeasureTheory.Integrab... | Integrability in the change of variable formula for differentiable functions: if a real
function `f` is monotone and differentiable on a measurable set `s`, then a function
`g : ℝ → F` is integrable on `f '' s` if and only if `f' x • g ∘ f` is integrable on `s` . | true |
Metric.isCompact_closure_iff_exists_finite_isCover | Mathlib.Topology.MetricSpace.Cover | ∀ {X : Type u_1} [inst : MetricSpace X] [ProperSpace X] {ε : NNReal} {s : Set X},
ε ≠ 0 → (IsCompact (closure s) ↔ ∃ N ⊆ s, N.Finite ∧ Metric.IsCover ε s N) | A set in a proper metric space admits a finite cover iff it is relatively compact.
[R. Vershynin, *High Dimensional Probability*][vershynin2018high], 4.2.3. Note that the print
edition incorrectly claims that this holds without the `ProperSpace X` assumption. | true |
_private.Mathlib.NumberTheory.LucasLehmer.0.LucasLehmer.norm_num_ext.sModNatTR.go.match_1.eq_1 | Mathlib.NumberTheory.LucasLehmer | ∀ (motive : ℕ → ℕ → Sort u_1) (acc : ℕ) (h_1 : (acc : ℕ) → motive 0 acc) (h_2 : (n acc : ℕ) → motive n.succ acc),
(match 0, acc with
| 0, acc => h_1 acc
| n.succ, acc => h_2 n acc) =
h_1 acc | null | true |
Lean.PrettyPrinter.Delaborator.SubExpr.withBoundedAppFnArgs | Lean.PrettyPrinter.Delaborator.SubExpr | {α : Type} →
{m : Type → Type} →
[Monad m] → [MonadReaderOf Lean.SubExpr m] → [MonadWithReaderOf Lean.SubExpr m] → ℕ → m α → (α → m α) → m α | Uses `xa` to compute the fold across up to `maxArgs` outermost arguments of an application,
where `xf` provides the initial value and is evaluated in the context of the application minus
the arguments being folded across.
| true |
Lean.Meta.Grind.saveEMatchDiagInfo | Lean.Meta.Tactic.Grind.Types | List Lean.Meta.Grind.EMatchDiagNode → Lean.Meta.Grind.EMatchDiagNode → Lean.Meta.Grind.GrindM Unit | null | true |
CategoryTheory.PreGaloisCategory.surjective_of_nonempty_fiber_of_isConnected | Mathlib.CategoryTheory.Galois.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] (F : CategoryTheory.Functor C FintypeCat)
[inst_1 : CategoryTheory.PreGaloisCategory C] [CategoryTheory.PreGaloisCategory.FiberFunctor F] {X A : C}
[Nonempty (F.obj X).obj] [CategoryTheory.PreGaloisCategory.IsConnected A] (f : X ⟶ A),
Function.Surjective... | A morphism from an object with non-empty fiber to a connected object is surjective on fibers. | true |
Array.set_eraseIdx._proof_3 | Init.Data.Array.Erase | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} {w : i < xs.size} {j : ℕ} {a : α} (h' : ¬i ≤ j), i < (xs.set j a ⋯).size | null | false |
CategoryTheory.MorphismProperty.Comma.mapRightEq_inv_app_left | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {B : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] {T : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} T]
(L : CategoryTheory.Functor A T) {P : CategoryTheory.MorphismProperty T} {Q : CategoryTheory.MorphismProperty A}
{W : Categor... | null | true |
LowerSet.Iic_strictMono | Mathlib.Order.UpperLower.Principal | ∀ (α : Type u_1) [inst : Preorder α], StrictMono LowerSet.Iic | null | true |
Ideal.mulQuot._proof_1 | Mathlib.RingTheory.OrderOfVanishing.Basic | ∀ {R : Type u_1} [inst : CommRing R], SMulCommClass R R R | null | false |
Lean.Meta.instHashableInfoCacheKey._private_1 | Lean.Meta.Basic | Lean.Meta.InfoCacheKey → UInt64 | null | false |
CategoryTheory.hasExactLimitsOfShape_discrete_of_hasExactLimitsOfShape_finset_discrete_op | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[CategoryTheory.Limits.HasFiniteBiproducts C] [CategoryTheory.Limits.HasFiniteColimits C] (J : Type u_1)
[inst_4 : CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete J) C]
[inst_5 : CategoryTh... | `HasExactLimitsOfShape (Finset (Discrete J))ᵒᵖ C` implies `HasExactLimitsOfShape (Discrete J) C`
| true |
RootPairing.Hom.weight_coweight_transpose | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : 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] {ι₂ : Type u_5} {M₂ : Type u_6} {N₂ : Type u_7}
[inst_5 : AddCommGroup M₂] [inst_6 : Module R M₂] [inst_7 : AddCommGroup N₂] [inst_8 : Mod... | null | true |
Lean.IR.IRType.erased.elim | Lean.Compiler.IR.Basic | {motive_1 : Lean.IR.IRType → Sort u} →
(t : Lean.IR.IRType) → t.ctorIdx = 6 → motive_1 Lean.IR.IRType.erased → motive_1 t | null | false |
Batteries.Tactic.PrintPrefixConfig.showTypes._default | Batteries.Tactic.PrintPrefix | Bool | null | false |
LatticeCon.ctorIdx | Mathlib.Order.Lattice.Congruence | {α : Type u_2} → {inst : Lattice α} → LatticeCon α → ℕ | null | false |
CommSemiRingCat | Mathlib.Algebra.Category.Ring.Basic | Type (u + 1) | The category of commutative semirings. | true |
CategoryTheory.Limits.map_lift_equalizerComparison_assoc | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} {X Y : C} [inst : CategoryTheory.Category.{v, u} C] (f g : X ⟶ Y) {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D)
[inst_2 : CategoryTheory.Limits.HasEqualizer f g] [inst_3 : CategoryTheory.Limits.HasEqualizer (G.map f) (G.map g)]
{Z : C} {h : Z ⟶ X} (w :... | null | true |
CategoryTheory.Over.iteratedSliceForward_obj | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X)
(α : CategoryTheory.Over f),
f.iteratedSliceForward.obj α = CategoryTheory.Over.mk (CategoryTheory.Over.Hom.left α.hom) | null | true |
MeasureTheory.TendstoInMeasure.congr | Mathlib.MeasureTheory.Function.ConvergenceInMeasure | ∀ {α : Type u_1} {ι : Type u_2} {E : Type u_4} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : EDist E]
{l : Filter ι} {f f' : ι → α → E} {g g' : α → E},
(∀ (i : ι), f i =ᵐ[μ] f' i) →
g =ᵐ[μ] g' → MeasureTheory.TendstoInMeasure μ f l g → MeasureTheory.TendstoInMeasure μ f' l g' | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.equiv_of_beq._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
CoassocSimps.lid_comp_map_assoc | Mathlib.RingTheory.Coalgebra.CoassocSimps | ∀ {R : Type u_1} {M : Type u_3} {N : Type u_4} {P : Type u_5} {M' : Type u_6} [inst : CommSemiring R]
[inst_1 : AddCommMonoid M] [inst_2 : Module R M] [inst_3 : AddCommMonoid N] [inst_4 : Module R N]
[inst_5 : AddCommMonoid P] [inst_6 : Module R P] [inst_7 : AddCommMonoid M'] [inst_8 : Module R M'] (f : M →ₗ[R] R)
... | null | true |
Algebra.PreSubmersivePresentation.jacobian_ofAlgEquiv | Mathlib.RingTheory.Extension.Presentation.Submersive | ∀ {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : Algebra.PreSubmersivePresentation R S ι σ) {T : Type u_1} [inst_3 : CommRing T] [inst_4 : Algebra R T]
(e : S ≃ₐ[R] T) [inst_5 : Finite σ], (P.ofAlgEquiv e).jacobian = e P.jacobian | null | true |
CategoryTheory.AddMonObj.add_comp_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{M N X : C} [inst_2 : CategoryTheory.AddMonObj M] [inst_3 : CategoryTheory.AddMonObj N] (f₁ f₂ : X ⟶ M) (g : M ⟶ N)
[CategoryTheory.IsAddMonHom g] {Z : C} (h : N ⟶ Z),
CategoryTheory.CategoryStruct.c... | null | true |
_private.Mathlib.Algebra.SkewMonoidAlgebra.Lift.0.SkewMonoidAlgebra.domCongr._simp_1 | Mathlib.Algebra.SkewMonoidAlgebra.Lift | ∀ {k : Type u_1} {G : Type u_2} [inst : AddCommMonoid k] {G' : Type u_4} {G'' : Type u_5} (f : G ≃ G') (g : G' ≃ G'')
(l : SkewMonoidAlgebra k G),
SkewMonoidAlgebra.equivMapDomain g (SkewMonoidAlgebra.equivMapDomain f l) =
SkewMonoidAlgebra.equivMapDomain (f.trans g) l | null | false |
Finset.antidiagonal_mono_left | Mathlib.Data.Finset.MulAntidiagonal | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedCancelAddMonoid α] {s t : Set α}
{hs : s.IsPWO} {ht : t.IsPWO} {a : α} {u : Set α} {hu : u.IsPWO},
u ⊆ s → Finset.antidiagonal hu ht a ⊆ Finset.antidiagonal hs ht a | null | true |
_private.Init.Data.String.Basic.0.String.Pos.lt_of_le_of_ne._simp_1_1 | Init.Data.String.Basic | ∀ {s : String} {l r : s.Pos}, (l < r) = (l.offset < r.offset) | null | false |
_private.Mathlib.Order.Filter.Map.0.Filter.frequently_comap._simp_1_2 | Mathlib.Order.Filter.Map | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | null | false |
AdicCompletion.of_ofAlgEquiv_symm | Mathlib.RingTheory.AdicCompletion.Algebra | ∀ {S : Type u_5} [inst : CommRing S] (I : Ideal S) [inst_1 : IsAdicComplete I S] (x : AdicCompletion I S),
(AdicCompletion.of I S) ((AdicCompletion.ofAlgEquiv I).symm x) = x | null | true |
Lean.Meta.AbstractMVars.instMonadMCtxM | Lean.Meta.AbstractMVars | Lean.MonadMCtx Lean.Meta.AbstractMVars.M | null | true |
LinearMap.cancel_right | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {R₃ : Type u_4} {M₁ : Type u_9} {M₂ : Type u_10} {M₃ : Type u_11} [inst : Semiring R₁]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂]
[inst_5 : AddCommMonoid M₃] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂} {module_M₃ ... | null | true |
_private.Mathlib.Topology.MetricSpace.CoveringNumbers.0.Metric.encard_maximalSeparatedSet._proof_1_4 | Mathlib.Topology.MetricSpace.CoveringNumbers | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X] {A : Set X} {ε : NNReal},
Metric.packingNumber ε A ≠ ⊤ → (Metric.maximalSeparatedSet ε A).encard = Metric.packingNumber ε A | null | false |
MeasureTheory.Measure.restrict_mono_measure | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {x : MeasurableSpace α} {μ ν : MeasureTheory.Measure α},
μ ≤ ν → ∀ (s : Set α), μ.restrict s ≤ ν.restrict s | null | true |
_private.Mathlib.RingTheory.AlgebraicIndependent.Transcendental.0.lift_trdeg_add_le._simp_1_1 | Mathlib.RingTheory.AlgebraicIndependent.Transcendental | ∀ (α : Type u) (β : Type v),
Cardinal.lift.{v, u} (Cardinal.mk α) + Cardinal.lift.{u, v} (Cardinal.mk β) = Cardinal.mk (α ⊕ β) | null | false |
Ideal.mapCotangent | Mathlib.RingTheory.Ideal.Cotangent | {R : Type u} →
[inst : CommRing R] →
{A : Type u_1} →
{B : Type u_2} →
[inst_1 : CommRing A] →
[inst_2 : CommRing B] →
[inst_3 : Algebra R A] →
[inst_4 : Algebra R B] →
(I₁ : Ideal A) →
(I₂ : Ideal B) → (f : A →ₐ[R] B) → I₁ ≤ Idea... | The map `I/I² → J/J²` if `I ≤ f⁻¹(J)`. | true |
Ordnode.split3._unsafe_rec | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [DecidableLE α] → α → Ordnode α → Ordnode α × Option α × Ordnode α | null | false |
Lean.Lsp.RpcWireFormat.v1.elim | Lean.Server.Rpc.Basic | {motive : Lean.Lsp.RpcWireFormat → Sort u} →
(t : Lean.Lsp.RpcWireFormat) → t.ctorIdx = 1 → motive Lean.Lsp.RpcWireFormat.v1 → motive t | null | false |
Cardinal.lt_aleph0_iff_finite | Mathlib.SetTheory.Cardinal.Basic | ∀ {α : Type u}, Cardinal.mk α < Cardinal.aleph0 ↔ Finite α | null | true |
Matrix.trace_zero | Mathlib.LinearAlgebra.Matrix.Trace | ∀ (n : Type u_3) (R : Type u_6) [inst : Fintype n] [inst_1 : AddCommMonoid R], Matrix.trace 0 = 0 | null | true |
_private.Mathlib.RingTheory.PowerSeries.Basic.0.PowerSeries.coeff_one_pow._simp_1_5 | Mathlib.RingTheory.PowerSeries.Basic | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
RootPairing.root | 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] → RootPairing ι R M N → ι ↪ M | A parametrized family of vectors, called roots. | true |
_private.Mathlib.Data.Int.Basic.0.Int.natCast_dvd._simp_1_2 | Mathlib.Data.Int.Basic | ∀ {a b : ℤ}, (a ∣ -b) = (a ∣ b) | null | false |
_private.Mathlib.NumberTheory.ModularForms.Bounds.0.CuspFormClass.exists_sum_range_norm_sq_qExpansion_coeff_le_of_mem_strictPeriods._simp_1_3 | Mathlib.NumberTheory.ModularForms.Bounds | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
Turing.ListBlank.tail_mk | Mathlib.Computability.TuringMachine.Tape | ∀ {Γ : Type u_1} [inst : Inhabited Γ] (l : List Γ), (Turing.ListBlank.mk l).tail = Turing.ListBlank.mk l.tail | null | true |
CategoryTheory.Mat_.instAddCommGroupHom._proof_20 | Mathlib.CategoryTheory.Preadditive.Mat | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(M N : CategoryTheory.Mat_ C),
autoParam (∀ (n : ℕ) (a : M ⟶ N), ↑n.succ • a = ↑n • a + a) SubNegMonoid.zsmul_succ'._autoParam | null | false |
Mathlib.Meta.FunProp.FunctionTheorem.appliedArgs | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.FunctionTheorem → ℕ | total number of arguments applied to the function | true |
Nat.one_eq_digitChar | Init.Data.Nat.ToString | ∀ {n : ℕ}, '1' = n.digitChar ↔ n = 1 | null | true |
RestrictedProduct.instNSMul | 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 : ι) → AddMonoid (R i)] →
[∀ (i : ι), AddSubmonoidClass (S i) (R i)] → SMul ℕ (RestrictedProduct (fun i => R i)... | null | true |
Lean.Grind.eq_true_of_and_eq_true_right | Init.Grind.Lemmas | ∀ {a b : Prop}, (a ∧ b) = True → b = True | null | true |
_private.Init.Data.String.Iterator.0.String.Legacy.Iterator.remainingBytes.match_1 | Init.Data.String.Iterator | (motive : String.Legacy.Iterator → Sort u_1) →
(x : String.Legacy.Iterator) → ((s : String) → (i : String.Pos.Raw) → motive { s := s, i := i }) → motive x | null | false |
FunLike.commRing._proof_10 | Mathlib.Algebra.Ring.FunLike | ∀ {F : Type u_3} {α : Type u_1} {β : Type u_2} [inst : FunLike F α β] [inst_1 : NatCast F] [inst_2 : CommRing β]
[IsNatCastApply F α β] (n : ℕ), ⇑↑n = ↑n | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.ordered_keys_toList._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
WeierstrassCurve.Jacobian.Point.zero_def | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} [inst_1 : Nontrivial R],
0 = { point := ⟦![1, 1, 0]⟧, nonsingular := ⋯ } | null | true |
TestFunction.instAddCommGroup._proof_1 | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_2}
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {n : ℕ∞} (a b c : TestFunction Ω F n),
a + b + c = a + (b + c) | null | false |
MulAction.IsPreprimitive.of_surjective | Mathlib.GroupTheory.GroupAction.Primitive | ∀ {M : Type u_3} [inst : Group M] {α : Type u_4} [inst_1 : MulAction M α] {N : Type u_5} {β : Type u_6}
[inst_2 : Group N] [inst_3 : MulAction N β] {φ : M → N} {f : α →ₑ[φ] β} [MulAction.IsPreprimitive M α],
Function.Surjective ⇑f → MulAction.IsPreprimitive N β | null | true |
Std.DTreeMap.Raw.Const.get!_diff | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {m₁ m₂ : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp]
[inst : Inhabited β],
m₁.WF →
m₂.WF →
∀ {k : α},
Std.DTreeMap.Raw.Const.get! (m₁ \ m₂) k =
if m₂.contains k = true then default else Std.DTreeMap.Raw.Const.get! m₁ k | null | true |
abs_sub_sup_add_abs_sub_inf | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddCommGroup α] [AddLeftMono α] (a b c : α),
|a ⊔ c - b ⊔ c| + |a ⊓ c - b ⊓ c| = |a - b| | null | true |
Sigma.isPreconnected_iff | Mathlib.Topology.Connected.Clopen | ∀ {ι : Type u_1} {X : ι → Type u_2} [hι : Nonempty ι] [inst : (i : ι) → TopologicalSpace (X i)]
{s : Set ((i : ι) × X i)}, IsPreconnected s ↔ ∃ i t, IsPreconnected t ∧ s = Sigma.mk i '' t | null | true |
Module.Basis.constr_basis | Mathlib.LinearAlgebra.Basis.Defs | ∀ {M' : Type u_5} [inst : AddCommMonoid M'] {ι : Type u_7} {R : Type u_8} {M : Type u_9} [inst_1 : Semiring R]
[inst_2 : AddCommMonoid M] [inst_3 : Module R M] (b : Module.Basis ι R M) [inst_4 : Module R M'] (S : Type u_10)
[inst_5 : Semiring S] [inst_6 : Module S M'] [inst_7 : SMulCommClass R S M'] (f : ι → M') (i... | null | true |
CategoryTheory.Reflective.comparison_full | Mathlib.CategoryTheory.Monad.Adjunction | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{R : CategoryTheory.Functor D C} [R.Full] {L : CategoryTheory.Functor C D} (adj : L ⊣ R),
(CategoryTheory.Monad.comparison adj).Full | null | true |
Finpartition.mem_part_ofSetSetoid_iff_rel | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Setoid α} (x : Finset α) [inst_1 : DecidableRel ⇑s] {b : α},
b ∈ (Finpartition.ofSetSetoid s x).part a ↔ a ∈ x ∧ b ∈ x ∧ s a b | null | true |
_private.Mathlib.Probability.Process.LocalProperty.0.ProbabilityTheory.isPreLocalizingSequence_of_isLocalizingSequence_aux | Mathlib.Probability.Process.LocalProperty | ∀ {ι : Type u_1} {Ω : Type u_2} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω}
[inst : ConditionallyCompleteLinearOrderBot ι] [inst_1 : TopologicalSpace ι] [inst_2 : OrderTopology ι]
{𝓕 : MeasureTheory.Filtration ι mΩ} [SecondCountableTopology ι] [MeasureTheory.IsFiniteMeasure P]
{τ : ℕ → Ω → WithTop ι} ... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.