name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
IntermediateField.extendScalars_self | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {K : Type u_1} [inst : Field K] {L : Type u_2} [inst_1 : Field L] [inst_2 : Algebra K L] (F : IntermediateField K L),
IntermediateField.extendScalars ⋯ = ⊥ | null | true |
noConfusionTypeEnum | Init.Core | {α : Sort u} → (α → ℕ) → Sort w → α → α → Sort w | Auxiliary definition for generating compact `noConfusion` for enumeration types | true |
Lean.Elab.Tactic.Grind.SimpCacheKey.mk.injEq | Lean.Elab.Tactic.Grind.Basic | ∀ (variant : Lean.Name) (extras : Array Lean.Elab.Tactic.Grind.ExtraTheorem) (variant_1 : Lean.Name)
(extras_1 : Array Lean.Elab.Tactic.Grind.ExtraTheorem),
({ variant := variant, extras := extras } = { variant := variant_1, extras := extras_1 }) =
(variant = variant_1 ∧ extras = extras_1) | null | true |
Subfield.extendScalars.orderIso._proof_5 | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {L : Type u_1} [inst : Field L] (F : Subfield L) (E : IntermediateField (↥F) L) (x : L) (hx : x ∈ F),
(algebraMap (↥F) L) ⟨x, hx⟩ ∈ E | null | false |
Lean.Lsp.SemanticTokenType.leanSorryLike | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SemanticTokenType | null | true |
_private.ImportGraph.Shake.Basic.0.ImportGraph.Shake.Needs.allWithKind.eq_1 | ImportGraph.Shake.Basic | ∀ (n : ImportGraph.Shake.Needs) (f : ImportGraph.Shake.NeedsKind → ImportGraph.Shake.Bitset → Bool),
n.allWithKind f = ImportGraph.Shake.NeedsKind.all.all fun k => n.applyAt k (f k) | null | true |
Std.DTreeMap.Raw.Const.mem_iff_isSome_get? | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp],
t.WF → ∀ {a : α}, a ∈ t ↔ (Std.DTreeMap.Raw.Const.get? t a).isSome = true | null | true |
ZetaAsymptotics.zeta_limit_aux1 | Mathlib.NumberTheory.Harmonic.ZetaAsymp | ∀ {s : ℝ}, 1 < s → ∑' (n : ℕ), 1 / (↑n + 1) ^ s - 1 / (s - 1) = 1 - s * ZetaAsymptotics.termTSum s | Reformulation of `ZetaAsymptotics.termTSum_of_lt` which is useful for some computations
below. | true |
Subfield.copy._proof_6 | Mathlib.Algebra.Field.Subfield.Defs | ∀ {K : Type u_1} [inst : DivisionRing K] (S : Subfield K) (s : Set K), s = ↑S → ∀ x ∈ s, x⁻¹ ∈ s | null | false |
Lean.IR.EmitLLVM.emitDel | Lean.Compiler.IR.EmitLLVM | {llvmctx : Lean.LLVM.Context} → Lean.LLVM.Builder llvmctx → Lean.IR.VarId → Lean.IR.EmitLLVM.M llvmctx Unit | null | true |
List.max?_eq_some_iff' | Init.Data.List.Nat.Basic | ∀ {a : ℕ} {xs : List ℕ}, xs.max? = some a ↔ a ∈ xs ∧ ∀ b ∈ xs, b ≤ a | null | true |
PiTensorProduct.reindex_trans | Mathlib.LinearAlgebra.PiTensorProduct.Basic | ∀ {ι : Type u_1} {ι₂ : Type u_2} {ι₃ : Type u_3} {R : Type u_4} [inst : CommSemiring R] {s : ι → Type u_7}
[inst_1 : (i : ι) → AddCommMonoid (s i)] [inst_2 : (i : ι) → Module R (s i)] (e : ι ≃ ι₂) (e' : ι₂ ≃ ι₃),
PiTensorProduct.reindex R s e ≪≫ₗ PiTensorProduct.reindex R (fun i => s (e.symm i)) e' =
PiTensorPr... | null | true |
_private.Std.Sat.CNF.RelabelFin.0.Std.Sat.CNF.not_exists_mem._simp_1_2 | Std.Sat.CNF.RelabelFin | ∀ {α : Type u_1} {l : List α}, (l.isEmpty = true) = (l = []) | null | false |
Ordinal.mul_two | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (o : Ordinal.{u_4}), o * 2 = o + o | null | true |
Complex.analyticAt_regularizedHGFun_of_card_le | Mathlib.Analysis.SpecialFunctions.RegularizedHypergeometric | ∀ {a b : Multiset ℂ}, a.card ≤ b.card → ∀ (z : ℂ), AnalyticAt ℂ (Complex.regularizedHGFun a b) z | null | true |
Polynomial.Gal.instUniqueOfFactSplits | Mathlib.FieldTheory.PolynomialGaloisGroup | {F : Type u_1} → [inst : Field F] → (p : Polynomial F) → [h : Fact p.Splits] → Unique p.Gal | null | true |
Matroid.loopyOn_isBasis_iff | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {E I X : Set α}, (Matroid.loopyOn E).IsBasis I X ↔ I = ∅ ∧ X ⊆ E | null | true |
_private.Mathlib.Order.Antichain.0.IsMaxAntichain.nonempty_iff._simp_1_1 | Mathlib.Order.Antichain | ∀ {α : Type u} {s : Set α}, (¬s.Nonempty) = (s = ∅) | null | false |
Topology.IsEmbedding.specialLinearGroup_map | Mathlib.Topology.Algebra.Group.Matrix | ∀ {n : Type u_1} {R : Type u_2} {S : Type u_3} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing R]
[inst_3 : TopologicalSpace R] [inst_4 : CommRing S] [inst_5 : TopologicalSpace S] {f : R →+* S},
Topology.IsEmbedding ⇑f → Topology.IsEmbedding ⇑(Matrix.SpecialLinearGroup.map f) | null | true |
EsakiaHom.toPseudoEpimorphism | Mathlib.Topology.Order.Hom.Esakia | {α : Type u_2} →
{β : Type u_3} →
[inst : TopologicalSpace α] →
[inst_1 : Preorder α] →
[inst_2 : TopologicalSpace β] → [inst_3 : Preorder β] → EsakiaHom α β → PseudoEpimorphism α β | null | true |
IndepMatroid.ofFinitaryCardAugment_E | Mathlib.Combinatorics.Matroid.IndepAxioms | ∀ {α : Type u_1} (E : Set α) (Indep : Set α → Prop) (indep_empty : Indep ∅)
(indep_subset : ∀ ⦃I J : Set α⦄, Indep J → I ⊆ J → Indep I)
(indep_aug :
∀ ⦃I J : Set α⦄, Indep I → I.Finite → Indep J → J.Finite → I.ncard < J.ncard → ∃ e ∈ J, e ∉ I ∧ Indep (insert e I))
(indep_compact : ∀ (I : Set α), (∀ J ⊆ I, J.F... | null | true |
ZLattice.sum_piFinset_Icc_rpow_le | Mathlib.Algebra.Module.ZLattice.Summable | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
{L : Submodule ℤ E} [inst_3 : DiscreteTopology ↥L] {ι : Type u_3} [inst_4 : Fintype ι] [inst_5 : DecidableEq ι]
(b : Module.Basis ι ℤ ↥L) {d : ℕ},
d = Fintype.card ι →
∀ (n : ℕ),
∀ r < -↑d,
... | null | true |
CliffordAlgebra.instRing._proof_8 | Mathlib.LinearAlgebra.CliffordAlgebra.Basic | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M), autoParam (∀ (x : CliffordAlgebra Q), 0 • x = 0) AddMonoid.nsmul_zero._autoParam | null | false |
_private.Mathlib.ModelTheory.Encoding.0.FirstOrder.Language.BoundedFormula.listEncode.match_1.eq_5 | Mathlib.ModelTheory.Encoding | ∀ {L : FirstOrder.Language} {α : Type u_3} (motive : (x : ℕ) → L.BoundedFormula α x → Sort u_4) (x : ℕ)
(φ : L.BoundedFormula α (x + 1)) (h_1 : (n : ℕ) → motive n FirstOrder.Language.BoundedFormula.falsum)
(h_2 : (x : ℕ) → (t₁ t₂ : L.Term (α ⊕ Fin x)) → motive x (FirstOrder.Language.BoundedFormula.equal t₁ t₂))
(... | null | true |
Lean.Elab.instInhabitedDefViewElabHeaderData.default | Lean.Elab.DefView | Lean.Elab.DefViewElabHeaderData | null | true |
CochainComplex.mappingCone.mapOfHomotopy | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] →
{K₁ L₁ K₂ L₂ : CochainComplex C ℤ} →
{φ₁ : K₁ ⟶ L₁} →
{φ₂ : K₂ ⟶ L₂} →
{a : K₁ ⟶ K₂} →
... | The morphism `mappingCone φ₁ ⟶ mappingCone φ₂` that is induced by a square that
is commutative up to homotopy. | true |
DivisionRing.nnratCast_def | Mathlib.Algebra.Field.Defs | ∀ {K : Type u_2} [self : DivisionRing K] (q : ℚ≥0), ↑q = ↑q.num / ↑q.den | However `NNRat.cast` is defined, it must be equal to `a / b`.
Do not use this lemma directly. Use `NNRat.cast_def` instead. | true |
IsLocalization.noZeroDivisors | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [IsLocalization M S] [NoZeroDivisors R], NoZeroDivisors S | Any localization of a commutative semiring without zero-divisors also has no zero-divisors. | true |
Std.OrientedCmp.not_isGE_of_gt | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.OrientedCmp cmp] {a b : α}, cmp a b = Ordering.gt → ¬(cmp b a).isGE = true | null | true |
Std.WP.WP.of_frameClosure_le_wp_iff | Std.WP.Frame | ∀ {Prog : Type u} {Value : Type v} {Pred : Type w} {EPred : Type z} [inst : Std.WP.Assertion Pred]
[inst_1 : Std.WP.Assertion EPred] {R : Type t} (op : R → Pred → Pred)
[inst_2 : ∀ (r : R), Lean.Order.PreservesSup (op r)] (base : Std.WP.WP Prog Value Pred EPred) (x : Prog)
(Q : Value → Pred) (E : EPred) (pre : Pr... | Characterization of the `WP.of_frameClosure` weakest precondition: landing below it is landing
below the base wp with every resource `op r` framed onto the pre- and postcondition. | true |
CategoryTheory.Localization.lift₂NatIso.eq_1 | Mathlib.CategoryTheory.Localization.Monoidal.Braided | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {D₁ : Type u_3} {D₂ : Type u_4} {E : Type u_5}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_3} D₁] [inst_3 : CategoryTheory.Category.{v_4, u_4} D₂]
[inst_4 : CategoryTheory.Category.{v_5,... | null | true |
Continuous.cfcₙ_nnreal._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | Lean.Syntax | null | false |
_private.Lean.Parser.Syntax.0.Lean.Parser.Command.mixfix._regBuiltin.Lean.Parser.Command.infix.parenthesizer_49 | Lean.Parser.Syntax | IO Unit | null | false |
Std.Time.Modifier.Z | Std.Time.Format.Modifier | Std.Time.OffsetZ → Std.Time.Modifier | `Z`: Zone offset.
- `Z`, `ZZ`, `ZZZ`: output `±HHMMss` (no colon); parse `±HHMM[ss]`. Does **not** accept the literal `Z` character for UTC — use `ZZZZZ` or `XXX` for that.
- `ZZZZ`: outputs/parses localized GMT form (e.g., `GMT+08:00`).
- `ZZZZZ`: outputs `±HH:mm[:ss]` and uses `Z` for UTC (e.g., `Z`, `+01:30`).
| true |
Lean.Lsp.instToJsonInlayHintKind.match_1 | Lean.Data.Lsp.LanguageFeatures | (motive : Lean.Lsp.InlayHintKind → Sort u_1) →
(x : Lean.Lsp.InlayHintKind) →
(Unit → motive Lean.Lsp.InlayHintKind.type) → (Unit → motive Lean.Lsp.InlayHintKind.parameter) → motive x | null | false |
differentiableAt_add_const_iff._simp_1 | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} (c : F), DifferentiableAt 𝕜 (fun y => f y + c) x = DifferentiableAt 𝕜 f x | null | false |
Lean.Meta.Occurrences.rec | Init.MetaTypes | {motive : Lean.Meta.Occurrences → Sort u} →
motive Lean.Meta.Occurrences.all →
((idxs : List ℕ) → motive (Lean.Meta.Occurrences.pos idxs)) →
((idxs : List ℕ) → motive (Lean.Meta.Occurrences.neg idxs)) → (t : Lean.Meta.Occurrences) → motive t | null | false |
_private.Mathlib.MeasureTheory.Integral.Lebesgue.Basic.0.MeasureTheory.le_iInf_lintegral._simp_1_1 | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_8} {β : α → Type u_9} {ι : Sort u_10} [inst : (i : α) → InfSet (β i)] {f : ι → (a : α) → β a} {a : α},
⨅ i, f i a = (⨅ i, f i) a | null | false |
Real.Wallis.W._proof_1 | Mathlib.Analysis.Real.Pi.Wallis | (1 + 1).AtLeastTwo | null | false |
CategoryTheory.GradedObject.mapBifunctorMapMapIso._proof_1 | Mathlib.CategoryTheory.GradedObject.Bifunctor | ∀ {C₁ : Type u_5} {C₂ : Type u_7} {C₃ : Type u_3} [inst : CategoryTheory.Category.{u_4, u_5} C₁]
[inst_1 : CategoryTheory.Category.{u_6, u_7} C₂] [inst_2 : CategoryTheory.Category.{u_2, u_3} C₃]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)) {I : Type u_8} {J : Type u_9} {K : Type u_1}
(p : I × J ... | null | false |
Set.one_subset | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : One α] {s : Set α}, 1 ⊆ s ↔ 1 ∈ s | null | true |
Std.ExtDTreeMap.Const.ordered_keys_toList | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp],
List.Pairwise (fun a b => cmp a.1 b.1 = Ordering.lt) (Std.ExtDTreeMap.Const.toList t) | null | true |
Batteries.Tactic.Instances._aux_Batteries_Tactic_Instances___elabRules_Batteries_Tactic_Instances_instancesCmd_1 | Batteries.Tactic.Instances | Lean.Elab.Command.CommandElab | `#instances term` prints all the instances for the given class.
For example, `#instances Add _` gives all `Add` instances, and `#instances Add Nat` gives the
`Nat` instance. The `term` can be any type that can appear in `[...]` binders.
Trailing underscores can be omitted, and `#instances Add` and `#instances Add _` a... | false |
LowerSemicontinuousWithinAt.inv | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_4} [inst : TopologicalSpace α] {β : Type u_5} {f : α → β} {s : Set α} {a : α} [inst_1 : PartialOrder β]
[inst_2 : CommGroup β] [IsOrderedMonoid β], LowerSemicontinuousWithinAt f s a → UpperSemicontinuousWithinAt f⁻¹ s a | **Alias** of the reverse direction of `upperSemicontinuousWithinAt_inv_iff`. | true |
Lean.Elab.Tactic.Omega.Justification.combine.sizeOf_spec | Lean.Elab.Tactic.Omega.Core | ∀ {s t : Lean.Omega.Constraint} {c : Lean.Omega.Coeffs} (j : Lean.Elab.Tactic.Omega.Justification s c)
(k : Lean.Elab.Tactic.Omega.Justification t c),
sizeOf (j.combine k) = 1 + sizeOf s + sizeOf t + sizeOf c + sizeOf j + sizeOf k | null | true |
Monoid.Coprod.swap_eq_one._simp_2 | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {x : Monoid.Coprod M N},
((Monoid.Coprod.swap M N) x = 1) = (x = 1) | null | false |
Fin.cast_rev | Mathlib.Data.Fin.Rev | ∀ {n m : ℕ} (i : Fin n) (h : n = m), Fin.cast h i.rev = (Fin.cast h i).rev | null | true |
_private.Mathlib.LinearAlgebra.FixedSubmodule.0.LinearMap.fixedSubmodule_eq_ker._simp_1_1 | Mathlib.LinearAlgebra.FixedSubmodule | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
BoundingSieve.inv_selbergTerms_eq_sum_divisors_moebius_nu.match_1 | Mathlib.NumberTheory.SelbergSieve | (motive : ℕ × ℕ → Sort u_1) → (x : ℕ × ℕ) → ((d e : ℕ) → motive (d, e)) → motive x | null | false |
FP.RMode.NE.sizeOf_spec | Mathlib.Data.FP.Basic | sizeOf FP.RMode.NE = 1 | null | true |
Std.DTreeMap.Raw.Const.getD_inter_of_not_mem_left | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {m₁ m₂ : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp],
m₁.WF → m₂.WF → ∀ {k : α} {fallback : β}, k ∉ m₁ → Std.DTreeMap.Raw.Const.getD (m₁ ∩ m₂) k fallback = fallback | null | true |
CategoryTheory.Bicategory.instIsIsoHomLeftZigzagHom | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {a b : B} {f : a ⟶ b} {g : b ⟶ a}
(η : CategoryTheory.CategoryStruct.id a ≅ CategoryTheory.CategoryStruct.comp f g)
(ε : CategoryTheory.CategoryStruct.comp g f ≅ CategoryTheory.CategoryStruct.id b),
CategoryTheory.IsIso (CategoryTheory.Bicategory.leftZigzag η.h... | null | true |
Subgroup.map_center_le_center | Mathlib.GroupTheory.Subgroup.Center | ∀ {G : Type u_1} {H : Type u_2} [inst : Group G] [inst_1 : Group H] {F : Type u_3} [inst_2 : FunLike F G H]
[inst_3 : MonoidHomClass F G H] {f : F},
Function.Surjective ⇑f → Subgroup.map (↑f) (Subgroup.center G) ≤ Subgroup.center H | null | true |
Lean.Meta.Sym.Arith.Semiring.addFn?._default | Lean.Meta.Sym.Arith.Types | Option Lean.Expr | null | false |
Lean.LocalContext.findDecl? | Lean.LocalContext | {β : Type u_1} → Lean.LocalContext → (Lean.LocalDecl → Option β) → Option β | null | true |
_private.Mathlib.GroupTheory.Finiteness.0.AddMonoid.isAddFG_iff.match_1_5 | Mathlib.GroupTheory.Finiteness | ∀ {M : Type u_1} [inst : AddZeroClass M] (motive : (∃ S, {0} ∪ ↑(AddSubsemigroup.closure ↑S) = Set.univ) → Prop)
(x : ∃ S, {0} ∪ ↑(AddSubsemigroup.closure ↑S) = Set.univ),
(∀ (S : Finset M) (hS : {0} ∪ ↑(AddSubsemigroup.closure ↑S) = Set.univ), motive ⋯) → motive x | null | false |
_private.Mathlib.CategoryTheory.Abelian.GrothendieckCategory.ModuleEmbedding.Opposite.0.CategoryTheory.Abelian.IsGrothendieckAbelian.OppositeModuleEmbedding.generator | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.ModuleEmbedding.Opposite | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type v} →
[inst_1 : CategoryTheory.SmallCategory D] →
CategoryTheory.Functor D Cᵒᵖ →
[inst_2 : CategoryTheory.Abelian C] → [CategoryTheory.IsGrothendieckAbelian.{v, v, u} C] → Cᵒᵖ | null | true |
Lists'.mem_of_subset' | Mathlib.SetTheory.Lists | ∀ {α : Type u_1} {a : Lists α} {l₁ l₂ : Lists' α true}, l₁ ⊆ l₂ → a ∈ l₁.toList → a ∈ l₂ | null | true |
_private.Mathlib.Data.Finset.NatDivisors.0.Nat.divisors_mul._simp_1_2 | Mathlib.Data.Finset.NatDivisors | ∀ {n m : ℕ}, (n ∈ m.divisors) = (n ∣ m ∧ m ≠ 0) | null | false |
ModP.preVal_eq_zero | Mathlib.RingTheory.Perfection | ∀ {K : Type u₁} [inst : Field K] {v : Valuation K NNReal} {O : Type u₂} [inst_1 : CommRing O] [inst_2 : Algebra O K],
v.Integers O → ∀ {p : ℕ} {x : ModP O p}, ModP.preVal K v O p x = 0 ↔ x = 0 | null | true |
Finset.mem_coe | Mathlib.Data.Finset.Defs | ∀ {α : Type u_1} {a : α} {s : Finset α}, a ∈ ↑s ↔ a ∈ s | null | true |
Lean.SubExpr.Pos.pushAppFn | Lean.SubExpr | Lean.SubExpr.Pos → Lean.SubExpr.Pos | null | true |
_private.Mathlib.LinearAlgebra.LinearIndependent.Lemmas.0.exists_of_linearIndepOn_of_finite_span._simp_1_13 | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {α : Type u} {a b : Set α}, (a = b) = ∀ (x : α), x ∈ a ↔ x ∈ b | null | false |
MonoidAlgebra.liftNCAlgHom._proof_1 | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B], RingHomClass (A →ₐ[R] B) A B | null | false |
Std.Http.Chunk.mk.sizeOf_spec | Std.Http.Data.Chunk | ∀ (data : ByteArray) (extensions : Array (Std.Http.Chunk.ExtensionName × Option Std.Http.Chunk.ExtensionValue)),
sizeOf { data := data, extensions := extensions } = 1 + sizeOf data + sizeOf extensions | null | true |
ContDiffWithinAt.congr_of_mem | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f f₁ : E → F} {x : E} {n : WithTop ℕ∞},
ContDiffWithinAt 𝕜 n f s x → (∀ y ∈ s, f₁ y = f y) → x ∈ s →... | null | true |
isIntegral_algebraMap_iff | Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Ring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Algebra A B] [IsScalarTower R A B] {x : A} [FaithfulSMul A B],
IsIntegral R ((algebraMap A B) x) ↔ IsIntegral R x | null | true |
AlgebraicGeometry.SheafedSpace.comp_hom_c_app' | Mathlib.Geometry.RingedSpace.SheafedSpace | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : AlgebraicGeometry.SheafedSpace C} (α : X ⟶ Y)
(β : Y ⟶ Z) (U : TopologicalSpace.Opens ↑↑Z.toPresheafedSpace),
(CategoryTheory.CategoryStruct.comp α β).hom.c.app (Opposite.op U) =
CategoryTheory.CategoryStruct.comp (β.hom.c.app (Opposite.op U))
... | null | true |
_private.Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace.0.Besicovitch.SatelliteConfig.exists_normalized_aux3._simp_1_4 | Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
inner_gradientWithin_left | Mathlib.Analysis.Calculus.Gradient.Basic | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup F] [inst_2 : InnerProductSpace 𝕜 F]
[inst_3 : CompleteSpace F] {f : F → 𝕜} {x y : F} {s : Set F},
inner 𝕜 (gradientWithin f s x) y = (fderivWithin 𝕜 f s x) y | null | true |
dimH_orthogonalProjection_le | Mathlib.Topology.MetricSpace.HausdorffDimension | ∀ {𝕜 : Type u_4} {E : Type u_5} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E) [inst_3 : K.HasOrthogonalProjection] (s : Set E), dimH (⇑K.orthogonalProjectionOnto '' s) ≤ dimH s | **Alias** of `dimH_orthogonalProjectionOnto_le`.
---
The Hausdorff dimension of the orthogonal projection of a set `s` onto a subspace `K`
is less than or equal to the Hausdorff dimension of `s`.
| true |
Nat.zero_shiftRight | Init.Data.Nat.Lemmas | ∀ (n : ℕ), 0 >>> n = 0 | null | true |
Mathlib.Meta.Positivity.evalAddNorm | Mathlib.Analysis.Normed.Group.Basic | Mathlib.Meta.Positivity.PositivityExt | Extension for the `positivity` tactic: additive norms are always nonnegative, and positive
on non-zero inputs. | true |
CategoryTheory.Limits.coconeEquivalenceOpConeOp._proof_1 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] (F : CategoryTheory.Functor J C)
{X Y : CategoryTheory.Limits.Cocone F} (f : X ⟶ Y) (j : Jᵒᵖ),
CategoryTheory.CategoryStruct.comp f.hom.op (X.op.π.app j) = Y.op.π.app j | null | false |
CategoryTheory.Limits.IsZero.isoZero | Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] → {X : C} → CategoryTheory.Limits.IsZero X → (X ≅ 0) | Every zero object is isomorphic to *the* zero object. | true |
FreeMonoid.length_eq_four | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {v : FreeMonoid α},
v.length = 4 ↔ ∃ a b c d, v = FreeMonoid.of a * FreeMonoid.of b * FreeMonoid.of c * FreeMonoid.of d | null | true |
_private.Init.Data.Vector.Nat.0.Vector.prod_eq_zero_iff_exists_zero_nat._simp_1_2 | Init.Data.Vector.Nat | ∀ {xs : Array ℕ}, (xs.prod = 0) = ∃ x ∈ xs, x = 0 | null | false |
Lean.instBEqReducibilityStatus.beq | Lean.ReducibilityAttrs | Lean.ReducibilityStatus → Lean.ReducibilityStatus → Bool | null | true |
Std.TreeMap.Raw.getElem!_ofList_of_contains_eq_false | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : BEq α] [Std.LawfulBEqCmp cmp]
{l : List (α × β)} {k : α} [inst_2 : Inhabited β],
(List.map Prod.fst l).contains k = false → (Std.TreeMap.Raw.ofList l cmp)[k]! = default | null | true |
SemidirectProduct.congr'_apply_left | Mathlib.GroupTheory.SemidirectProduct | ∀ {N₁ : Type u_4} {G₁ : Type u_5} {N₂ : Type u_6} {G₂ : Type u_7} [inst : Group N₁] [inst_1 : Group G₁]
[inst_2 : Group N₂] [inst_3 : Group G₂] {φ₁ : G₁ →* MulAut N₁} (fn : N₁ ≃* N₂) (fg : G₁ ≃* G₂) (x : N₁ ⋊[φ₁] G₁),
((SemidirectProduct.congr' fn fg) x).left = fn x.left | null | true |
Booleanisation.instPartialOrder | Mathlib.Order.Booleanisation | {α : Type u_1} → [GeneralizedBooleanAlgebra α] → PartialOrder (Booleanisation α) | null | true |
Topology.IsEmbedding.toPartialHomeomorph._proof_3 | Mathlib.Topology.PartialHomeomorph.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : X → Y)
(h : Topology.IsEmbedding f) [inst_2 : Nonempty X], IsHomeomorph ⇑(Set.InjOn.toPartialEquiv f Set.univ ⋯).toEquiv | null | false |
Module.Relations.Solution.ofπ.congr_simp | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] {relations : Module.Relations A} {M : Type v} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] (π π_1 : (relations.G →₀ A) →ₗ[A] M) (e_π : π = π_1)
(hπ : ∀ (r : relations.R), π (relations.relation r) = 0),
Module.Relations.Solution.ofπ π hπ = Module.Relations.Solution.ofπ π_1 ⋯ | null | true |
right_le_midpoint | Mathlib.LinearAlgebra.AffineSpace.Ordered | ∀ {k : Type u_1} {E : Type u_2} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : IsStrictOrderedRing k]
[inst_3 : AddCommGroup E] [inst_4 : PartialOrder E] [IsOrderedAddMonoid E] [inst_6 : Module k E]
[IsStrictOrderedModule k E] [PosSMulReflectLE k E] {a b : E}, b ≤ midpoint k a b ↔ b ≤ a | null | true |
CochainComplex.ιMapBifunctor.congr_simp | Mathlib.Algebra.Homology.BifunctorShift | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {D : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} D]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms C₁] [inst_4 : CategoryTheory.Limits.HasZeroMorphisms C₂]
(K₁ : CochainCo... | null | true |
OneHomClass.toOneHom.eq_1 | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : One M] [inst_1 : One N] [inst_2 : FunLike F M N]
[inst_3 : OneHomClass F M N] (f : F), ↑f = { toFun := ⇑f, map_one' := ⋯ } | null | true |
Lean.Meta.pp.showLetValues.threshold | Lean.Meta.PPGoal | Lean.Option ℕ | null | true |
BooleanAlgebra.lt._inherited_default | Mathlib.Order.BooleanAlgebra.Defs | {α : Type u} → (α → α → Prop) → α → α → Prop | null | false |
Prod.commMagma | Mathlib.Algebra.Group.Prod | {M : Type u_3} → {N : Type u_4} → [CommMagma M] → [CommMagma N] → CommMagma (M × N) | null | true |
Finset.map_comp_coe_apply | Mathlib.Data.Finset.Functor | ∀ {α β : Type u} (h : α → β) (s : Multiset α), Finset.image h s.toFinset = (h <$> s).toFinset | null | true |
Algebra.SubmersivePresentation.jacobian_isUnit | 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]
[inst_3 : Finite σ] (self : Algebra.SubmersivePresentation R S ι σ), IsUnit self.jacobian | null | true |
Pi.mulActionWithZero._proof_1 | Mathlib.Algebra.GroupWithZero.Action.Pi | ∀ {I : Type u_1} {f : I → Type u_2} (α : Type u_3) [inst : MonoidWithZero α] [inst_1 : (i : I) → Zero (f i)]
[inst_2 : (i : I) → MulActionWithZero α (f i)] (a : α), a • 0 = 0 | null | false |
ENNReal.holderTriple_coe_iff._simp_1 | Mathlib.Basic.Real.ConjExponents | ∀ {p q r : NNReal}, r ≠ 0 → (↑p).HolderTriple ↑q ↑r = p.HolderTriple q r | null | false |
Setoid.map_equiv_eq_comap_symm | Mathlib.Order.Setoid.Basic | ∀ {α : Type u_1} {β : Type u_2} (e : α ≃ β) (s : Setoid α), s.map ⇑e = Setoid.comap (⇑e.symm) s | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.append_assoc'._proof_1 | Init.Data.BitVec.Lemmas | ∀ {w₁ w₂ w₃ : ℕ}, ¬w₁ + w₂ + w₃ = w₁ + (w₂ + w₃) → False | null | false |
CategoryTheory.CommaMorphism.mk._to_dual_1 | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
{L : CategoryTheory.Functor A T} →
{R : CategoryTheory.Functor B T} →
... | null | false |
MulActionHom.congr_fun | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [inst : SMul M X] {Y : Type u_6} [inst_1 : SMul N Y]
{f g : X →ₑ[φ] Y}, f = g → ∀ (x : X), f x = g x | null | true |
Partition.mk.inj | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} {inst : CompleteLattice α} {s : α} {parts : Set α} {sSupIndep' : sSupIndep parts}
{bot_notMem' : ⊥ ∉ parts} {sSup_eq' : sSup parts = s} {parts_1 : Set α} {sSupIndep'_1 : sSupIndep parts_1}
{bot_notMem'_1 : ⊥ ∉ parts_1} {sSup_eq'_1 : sSup parts_1 = s},
{ parts := parts, sSupIndep' := sSupIndep', b... | null | true |
ENNReal.eventuallyEq_of_toReal_eventuallyEq | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {α : Type u_1} {l : Filter α} {f g : α → ENNReal},
(∀ᶠ (x : α) in l, f x ≠ ⊤) →
(∀ᶠ (x : α) in l, g x ≠ ⊤) → ((fun x => (f x).toReal) =ᶠ[l] fun x => (g x).toReal) → f =ᶠ[l] g | null | true |
PartialEquiv.symm | Mathlib.Logic.Equiv.PartialEquiv | {α : Type u_1} → {β : Type u_2} → PartialEquiv α β → PartialEquiv β α | The inverse of a partial equivalence | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.