name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Set.iUnion_subset_iff._simp_1 | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {ι : Sort u_5} {s : ι → Set α} {t : Set α}, (⋃ i, s i ⊆ t) = ∀ (i : ι), s i ⊆ t | null | false |
Subalgebra.copy._proof_4 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S : Subalgebra R A) (s : Set A) (hs : s = ↑S), 0 ∈ (S.copy s hs).carrier | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialObject.ChainHomotopy.0.CategoryTheory.SimplicialObject.Homotopy.ToChainHomotopy.comm_succ._proof_1_28 | Mathlib.AlgebraicTopology.SimplicialObject.ChainHomotopy | ∀ (n a b j k : ℕ) (a_1 : Fin (n + 2 + 1)) (b_1 : Fin (n + 1 + 1)) (i : ℕ) (isLt : i < n + 1),
⟨i, isLt⟩.castSucc.succ = a_1 → ⟨i, isLt⟩.castSucc = b_1 → j < k → k + 1 = a → j = b → a = ↑a_1 → ¬b = ↑b_1 | null | false |
FractionalIdeal.ringEquivOfRingEquiv.congr_simp | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_5} {S : Type u_6} (K : Type u_7) (L : Type u_8) [inst : CommRing R] [inst_1 : IsDomain R]
[inst_2 : CommRing S] [inst_3 : IsDomain S] [inst_4 : CommRing K] [inst_5 : CommRing L] [inst_6 : Algebra R K]
[inst_7 : Algebra S L] [inst_8 : IsFractionRing R K] [inst_9 : IsFractionRing S L] (f f_1 : R ≃+* S),... | null | true |
Lean.Kernel.Diagnostics.mk.noConfusion | Lean.Environment | {P : Sort u} →
{unfoldCounter : Lean.PHashMap Lean.Name ℕ} →
{enabled : Bool} →
{unfoldCounter' : Lean.PHashMap Lean.Name ℕ} →
{enabled' : Bool} →
{ unfoldCounter := unfoldCounter, enabled := enabled } =
{ unfoldCounter := unfoldCounter', enabled := enabled' } →
(... | null | false |
Aesop.RuleResult._sizeOf_1 | Aesop.Search.Expansion | Aesop.RuleResult → ℕ | null | false |
OrderDual.instNonAssocRing._proof_3 | Mathlib.Algebra.Order.Ring.Synonym | ∀ {R : Type u_1} [inst : NonAssocRing R], autoParam (↑0 = 0) AddMonoidWithOne.natCast_zero._autoParam | null | false |
Lean.Server.GoToKind.ctorIdx | Lean.Server.GoTo | Lean.Server.GoToKind → ℕ | null | false |
Matrix.IsAdjMatrix.toGraph_compl_eq | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | ∀ {α : Type u_1} {V : Type u_2} [inst : DecidableEq α] [inst_1 : DecidableEq V] {A : Matrix V V α}
[inst_2 : MulZeroOneClass α] [inst_3 : Nontrivial α] (h : A.IsAdjMatrix), ⋯.toGraph = h.toGraphᶜ | null | true |
List.map_injective_iff._simp_1 | Mathlib.Data.List.Basic | ∀ {α : Type u} {β : Type v} {f : α → β}, Function.Injective (List.map f) = Function.Injective f | null | false |
CategoryTheory.Abelian.SpectralObject.leftHomologyDataShortComplex._proof_9 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : n₀ + 1 = n₁) (hn₂ : n₁ + 1 = ... | null | false |
Finsupp.instZero._proof_1 | Mathlib.Data.Finsupp.Defs | ∀ {α : Type u_1} {M : Type u_2} [inst : Zero M] (x : α), x ∈ ∅ ↔ 0 x ≠ 0 | null | false |
continuousSubring._proof_5 | Mathlib.Topology.ContinuousMap.Algebra | ∀ (α : Type u_1) (R : Type u_2) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace R] [inst_2 : Ring R]
[inst_3 : IsTopologicalRing R] {a b : α → R},
a ∈ (continuousAddSubgroup α R).carrier →
b ∈ (continuousAddSubgroup α R).carrier → a + b ∈ (continuousAddSubgroup α R).carrier | null | false |
FundamentalGroupoid.termπₘ | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | Lean.ParserDescr | The functor between fundamental groupoids induced by a continuous map. | true |
Lean.Parser.checkSimpFailure | Init.Notation | Lean.ParserDescr | `#check_simp t !~>` checks `simp` fails on reducing `t`.
| true |
Metric.unitSphere.coe_pow | Mathlib.Analysis.Normed.Field.UnitBall | ∀ {𝕜 : Type u_1} [inst : SeminormedRing 𝕜] [inst_1 : NormMulClass 𝕜] [inst_2 : NormOneClass 𝕜]
(x : ↑(Metric.sphere 0 1)) (n : ℕ), ↑(x ^ n) = ↑x ^ n | null | true |
SimpleGraph.deleteIncidenceSet | Mathlib.Combinatorics.SimpleGraph.DeleteEdges | {V : Type u_1} → SimpleGraph V → V → SimpleGraph V | Given a vertex `x`, remove the edges incident to `x` from the edge set. | true |
RootPairing.RootPositiveForm.form_apply_root_ne_zero | Mathlib.LinearAlgebra.RootSystem.RootPositive | ∀ {ι : Type u_1} {R : Type u_2} {S : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommRing S]
[inst_1 : LinearOrder S] [inst_2 : CommRing R] [inst_3 : Algebra S R] [inst_4 : AddCommGroup M] [inst_5 : Module R M]
[inst_6 : AddCommGroup N] [inst_7 : Module R N] {P : RootPairing ι R M N} [inst_8 : P.IsValuedIn S]
... | null | true |
ExistsContDiffBumpBase.y | Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] → [FiniteDimensional ℝ E] → [inst_3 : MeasurableSpace E] → [BorelSpace E] → ℝ → E → ℝ | An auxiliary function to construct partitions of unity on finite-dimensional real vector spaces.
It is the convolution between a smooth function of integral `1` supported in the ball of radius `D`,
with the indicator function of the closed unit ball. Therefore, it is smooth, equal to `1` on the
ball of radius `1 - D`, ... | true |
Finset.mem_map'._simp_1 | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} (f : α ↪ β) {a : α} {s : Finset α}, (f a ∈ Finset.map f s) = (a ∈ s) | null | false |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear.0.RootPairing.rootFormIn_self_smul_coroot._simp_1_3 | Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear | ∀ {ι : 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] (self : RootPairing ι R M N) (i j : ι),
self.coroot ((self.reflectionPerm i) j) =
self.coroot j - (self.toLinearMap (self.root i)) (se... | null | false |
Std.IterM.forIn_toList | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {m : Type w → Type u_1} {γ α β : Type w} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α Id β]
[Std.Iterators.Finite α Id] [inst_4 : Std.IteratorLoop α Id m] [Std.LawfulIteratorLoop α Id m] {it : Std.IterM Id β}
{f : β → γ → m (ForInStep γ)} {init : γ}, forIn it.toList.run init f = forIn it init f | null | true |
CategoryTheory.Precoverage.RespectsIso | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.Precoverage C → Prop | A precoverage respects isomorphisms if the property of being covering
is stable under isomorphism.
Use `PreZeroHypercover.presieve₀_mem_of_iso` for no universe restrictions. | true |
Complex.equivRealProdAddHom_symm_apply_re | Mathlib.Data.Complex.Basic | ∀ (p : ℝ × ℝ), (Complex.equivRealProdAddHom.symm p).re = p.1 | null | true |
Simps.AutomaticProjectionData.recOn | Mathlib.Tactic.Simps.NotationClass | {motive : Simps.AutomaticProjectionData → Sort u} →
(t : Simps.AutomaticProjectionData) →
((className : Lean.Name) →
(isNotation : Bool) →
(findArgs : Lean.Name) → motive { className := className, isNotation := isNotation, findArgs := findArgs }) →
motive t | null | false |
List.dropPrefix?_eq_some_iff._unary | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] {s : List α} (_x : (_ : List α) ×' List α),
_x.1.dropPrefix? _x.2 = some s ↔ ∃ p', _x.1 = p' ++ s ∧ (p' == _x.2) = true | null | false |
List.Cursor.pos_at | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {l : List α} {n : ℕ}, n < l.length → (List.Cursor.at l n).pos = n | null | true |
Topology.ContinuousMapGeneratedBy.continuousGeneratedBy_iff_uncurry | Mathlib.Topology.Convenient.HomSpace | ∀ {ι : Type t} {X : ι → Type u} [inst : (i : ι) → TopologicalSpace (X i)] {Y : Type v} [inst_1 : TopologicalSpace Y]
{Z : Type v'} [inst_2 : TopologicalSpace Z] {T : Type v''} [inst_3 : TopologicalSpace T]
[∀ (i : ι), LocallyCompactSpace (X i)] (g : Z → Topology.ContinuousMapGeneratedBy X Y T),
Topology.Continuou... | null | true |
_private.Mathlib.Order.Category.HeytAlg.0.HeytAlg.Hom.mk._flat_ctor | Mathlib.Order.Category.HeytAlg | {X Y : HeytAlg} → HeytingHom ↑X ↑Y → X.Hom Y | null | false |
_private.Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous.0.MvPolynomial.weightedTotalDegree'_eq_bot_iff._simp_1_2 | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] (f : β → α) (S : Finset β),
(S.sup f = ⊥) = ∀ s ∈ S, f s = ⊥ | null | false |
Sylow.normal_of_normalizer_normal | Mathlib.GroupTheory.Sylow | ∀ {G : Type u} [inst : Group G] {p : ℕ} [Fact (Nat.Prime p)] [Finite (Sylow p G)] (P : Sylow p G),
(Subgroup.normalizer ↑P).Normal → (↑P).Normal | null | true |
_private.Mathlib.RingTheory.MvPowerSeries.LexOrder.0.MvPowerSeries.coeff_ne_zero_of_lexOrder._simp_1_5 | Mathlib.RingTheory.MvPowerSeries.LexOrder | ∀ {α : Type u_3} {β : Type u_4} {S : Set α} {f : α ≃ β} {x : β}, (x ∈ ⇑f '' S) = (f.symm x ∈ S) | null | false |
BoxIntegral.Prepartition.splitMany_le_split | Mathlib.Analysis.BoxIntegral.Partition.Split | ∀ {ι : Type u_1} (I : BoxIntegral.Box ι) {s : Finset (ι × ℝ)} {p : ι × ℝ},
p ∈ s → BoxIntegral.Prepartition.splitMany I s ≤ BoxIntegral.Prepartition.split I p.1 p.2 | null | true |
Lean.getPPPiBinderNamesHygienic | Lean.PrettyPrinter.Delaborator.Options | Lean.Options → Bool | null | true |
Finset.sum_range_diag_flip | Mathlib.Algebra.BigOperators.Intervals | ∀ {M : Type u_3} [inst : AddCommMonoid M] (n : ℕ) (f : ℕ → ℕ → M),
∑ m ∈ Finset.range n, ∑ k ∈ Finset.range (m + 1), f k (m - k) =
∑ m ∈ Finset.range n, ∑ k ∈ Finset.range (n - m), f m k | null | true |
UInt64.zero_add | Init.Data.UInt.Lemmas | ∀ (a : UInt64), 0 + a = a | null | true |
Submodule.one | Mathlib.Algebra.Algebra.Operations | {R : Type u} → [inst : Semiring R] → {A : Type v} → [inst_1 : Semiring A] → [inst_2 : Module R A] → One (Submodule R A) | `1 : Submodule R A` is the submodule `R ∙ 1` of `A`.
| true |
AlgebraicGeometry.instIsIsoSchemeCoprodComparisonOppositeCommRingCatSpec | Mathlib.AlgebraicGeometry.Limits | ∀ (R S : CommRingCatᵒᵖ), CategoryTheory.IsIso (CategoryTheory.Limits.coprodComparison AlgebraicGeometry.Scheme.Spec R S) | null | true |
_private.Init.Data.String.Lemmas.Iter.0.Std.Iter.intercalateString.match_1.splitter | Init.Data.String.Lemmas.Iter | (motive : Option String → String → Sort u_1) →
(x : Option String) →
(x_1 : String) → ((sl : String) → motive none sl) → ((str sl : String) → motive (some str) sl) → motive x x_1 | null | true |
LieRingModule.toEnd_apply_apply | Mathlib.Algebra.Lie.Basic | ∀ (L : Type v) (M : Type w) [inst : LieRing L] [inst_1 : AddCommGroup M] [inst_2 : LieRingModule L M] (x : L) (m : M),
((LieRingModule.toEnd L M) x) m = ⁅x, m⁆ | null | true |
Lean.CodeAction.FindTacticResult.tactic.elim | Lean.Server.CodeActions.Provider | {motive : Lean.CodeAction.FindTacticResult → Sort u} →
(t : Lean.CodeAction.FindTacticResult) →
t.ctorIdx = 0 → ((a : Lean.Syntax.Stack) → motive (Lean.CodeAction.FindTacticResult.tactic a)) → motive t | null | false |
Lean.Parser.Term.liftMethod | Lean.Parser.Do | Lean.Parser.Parser | null | true |
DiscreteUniformity.mk | Mathlib.Topology.UniformSpace.DiscreteUniformity | ∀ {X : Type u_1} [u : UniformSpace X], u = ⊥ → DiscreteUniformity X | null | true |
Aesop.BaseRuleSetMember.normForwardRule.sizeOf_spec | Aesop.RuleSet.Member | ∀ (r₁ : Aesop.ForwardRule) (r₂ : Aesop.NormRule),
sizeOf (Aesop.BaseRuleSetMember.normForwardRule r₁ r₂) = 1 + sizeOf r₁ + sizeOf r₂ | null | true |
CategoryTheory.IsModHom.recOn | Mathlib.CategoryTheory.Monoidal.Mod | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] →
{A : C} →
[inst_4 : Cat... | null | false |
Complex.cpow_zero | Mathlib.Analysis.SpecialFunctions.Pow.Complex | ∀ (x : ℂ), x ^ 0 = 1 | null | true |
Std.Http.Protocol.H1.Error.other.injEq | Std.Http.Protocol.H1.Error | ∀ (message message_1 : String),
(Std.Http.Protocol.H1.Error.other message = Std.Http.Protocol.H1.Error.other message_1) = (message = message_1) | null | true |
Representation.finsupp | Mathlib.RepresentationTheory.Basic | {k : Type u_1} →
{G : Type u_2} →
[inst : CommSemiring k] →
[inst_1 : Monoid G] →
{A : Type u_4} →
[inst_2 : AddCommMonoid A] →
[inst_3 : Module k A] → Representation k G A → (α : Type u_6) → Representation k G (α →₀ A) | The representation on `α →₀ A` defined pointwise by a representation on `A`. | true |
Std.DTreeMap.minKey?_eq_some_iff_mem_and_forall | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] {km : α}, t.minKey? = some km ↔ km ∈ t ∧ ∀ k ∈ t, (cmp km k).isLE = true | null | true |
ConditionallyCompletePartialOrderSup.noConfusionType | Mathlib.Order.ConditionallyCompletePartialOrder.Defs | Sort u →
{α : Type u_3} →
ConditionallyCompletePartialOrderSup α → {α' : Type u_3} → ConditionallyCompletePartialOrderSup α' → Sort u | null | false |
instMonadEIO._aux_11 | Init.System.IO | {ε α β : Type} → EIO ε α → (Unit → EIO ε β) → EIO ε β | null | false |
Lean.instReprExpr.repr._f | Lean.Expr | (x : Lean.Expr) → Lean.Expr.below (motive := fun x => ℕ → Std.Format) x → ℕ → Std.Format | null | false |
Polynomial.root_right_of_root_gcd | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} {k : Type y} [inst : Field R] [inst_1 : CommSemiring k] [inst_2 : DecidableEq R] {ϕ : R →+* k}
{f g : Polynomial R} {α : k}, Polynomial.eval₂ ϕ α (EuclideanDomain.gcd f g) = 0 → Polynomial.eval₂ ϕ α g = 0 | null | true |
Stream'.get_map | Mathlib.Data.Stream.Init | ∀ {α : Type u} {β : Type v} (f : α → β) (n : ℕ) (s : Stream' α), (Stream'.map f s).get n = f (s.get n) | null | true |
ProofWidgets.Penrose.DiagramState.casesOn | ProofWidgets.Component.PenroseDiagram | {motive : ProofWidgets.Penrose.DiagramState → Sort u} →
(t : ProofWidgets.Penrose.DiagramState) →
((sub : String) →
(embeds : Std.HashMap String (String × ProofWidgets.Html)) → motive { sub := sub, embeds := embeds }) →
motive t | null | false |
Subsingleton.intro._flat_ctor | Init.Core | ∀ {α : Sort u}, (∀ (a b : α), a = b) → Subsingleton α | null | false |
Char.toString_eq_singleton | Init.Data.Char.Lemmas | ∀ {c : Char}, c.toString = String.singleton c | null | true |
Ideal.ramificationIdx_eq_of_isGaloisGroup | Mathlib.NumberTheory.RamificationInertia.Galois | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] (p : Ideal A)
(P Q : Ideal B) [hPp : P.IsPrime] [hp : P.LiesOver p] [hQp : Q.IsPrime] [Q.LiesOver p] (G : Type u_3)
[inst_4 : Group G] [Finite G] [inst_6 : MulSemiringAction G B] [IsGaloisGroup G A B],
p.ramificationI... | All the `Ideal.ramificationIdx` over a fixed maximal ideal are the same. | true |
_private.Mathlib.RingTheory.SimpleModule.Basic.0.IsSemisimpleModule.sSup_simples_le._simp_1_1 | Mathlib.RingTheory.SimpleModule.Basic | ∀ {R : Type u_2} [inst : Ring R] {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {m : Submodule R M},
IsSimpleModule R ↥m = IsAtom m | null | false |
Set.finite_iff_finite_of_encard_eq_encard | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s t : Set α}, s.encard = t.encard → (s.Finite ↔ t.Finite) | null | true |
Lean.Elab.Tactic.Do.SpecAttr.SpecProof.noConfusion | Lean.Elab.Tactic.Do.Attr | {P : Sort u} →
{t t' : Lean.Elab.Tactic.Do.SpecAttr.SpecProof} →
t = t' → Lean.Elab.Tactic.Do.SpecAttr.SpecProof.noConfusionType P t t' | null | false |
LipschitzOnWith.prodMk | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β]
[inst_2 : PseudoEMetricSpace γ] {s : Set α} {f : α → β} {g : α → γ} {Kf Kg : NNReal},
LipschitzOnWith Kf f s → LipschitzOnWith Kg g s → LipschitzOnWith (max Kf Kg) (fun x => (f x, g x)) s | If `f` and `g` are Lipschitz on `s`, so is the induced map `f × g` to the product type. | true |
Lean.Elab.Command.CoinductiveElabData.ref | Lean.Elab.Coinductive | Lean.Elab.Command.CoinductiveElabData → Lean.Syntax | Ref from the original `InductiveView` | true |
Lean.Meta.Hint.tryThisDiffWidget | Lean.Meta.Hint | Lean.Widget.Module | A widget for rendering code action suggestions in error messages. Generally, this widget should not
be used directly; instead, use `MessageData.hint`. Note that this widget is intended only for use
within message data; it may not display line breaks properly if rendered as a panel widget.
The props to this widget are ... | true |
Lean.Lsp.Range.mk.sizeOf_spec | Lean.Data.Lsp.BasicAux | ∀ (start «end» : Lean.Lsp.Position), sizeOf { start := start, «end» := «end» } = 1 + sizeOf start + sizeOf «end» | null | true |
NonarchAddGroupSeminorm.coe_iSup_apply | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : AddGroup E] {ι : Type u_6} (f : ι → NonarchAddGroupSeminorm E),
BddAbove (Set.range f) → ∀ {x : E}, (⨆ i, f i) x = ⨆ i, (f i) x | null | true |
Monotone.mapsTo_Icc | Mathlib.Order.Interval.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} [inst : Preorder α] [inst_1 : Preorder β] {a b : α},
Monotone f → Set.MapsTo f (Set.Icc a b) (Set.Icc (f a) (f b)) | null | true |
Prod.mk_lt_mk_iff_right._gcongr_1 | Mathlib.Order.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] {a : α} {b₁ b₂ : β},
b₁ < b₂ → (a, b₁) < (a, b₂) | null | false |
Std.DTreeMap.Internal.Impl.Const.getEntryGE.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} [inst : Ord α] [inst_1 : Std.TransOrd α] (k : α)
(x_3 : Std.DTreeMap.Internal.Impl.leaf.Ordered)
(he : ∃ a ∈ Std.DTreeMap.Internal.Impl.leaf, (compare a k).isGE = true),
Std.DTreeMap.Internal.Impl.Const.getEntryGE k Std.DTreeMap.Internal.Impl.leaf x_3 he = ⋯.elim | null | true |
Std.Do.SPred.Tactic.instHasFrameAndOfSimpAnd_1 | Std.Do.SPred.DerivedLaws | ∀ {φ : Prop} (σs : List (Type u_1)) (P P' Q' PQ : Std.Do.SPred σs) [Std.Do.SPred.Tactic.HasFrame P' Q' φ]
[Std.Do.SPred.Tactic.SimpAnd P Q' PQ], Std.Do.SPred.Tactic.HasFrame spred(P ∧ P') PQ φ | null | true |
instIsSemisimpleModuleOfIsSimpleModule | Mathlib.RingTheory.SimpleModule.Basic | ∀ (R : Type u_2) [inst : Ring R] (M : Type u_4) [inst_1 : AddCommGroup M] [inst_2 : Module R M] [IsSimpleModule R M],
IsSemisimpleModule R M | null | true |
CategoryTheory.MorphismProperty.Comma.Hom.ctorIdx | 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} →
{R : CategoryTheory.Functor B ... | null | false |
CategoryTheory.SymmetricCategory.mk | Mathlib.CategoryTheory.Monoidal.Braided.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[toBraidedCategory : CategoryTheory.BraidedCategory C] →
autoParam
(∀ (X Y : C),
CategoryTheory.CategoryStruct.comp (β_ X Y).hom (β_ Y X).hom =
Category... | null | true |
_private.Mathlib.Tactic.Ring.Compare.0.Mathlib.Tactic.Ring.proveLE.match_4 | Mathlib.Tactic.Ring.Compare | (motive : Option (Lean.Expr × Lean.Expr × Lean.Expr) → Sort u_1) →
(x : Option (Lean.Expr × Lean.Expr × Lean.Expr)) →
((α e₁ e₂ : Lean.Expr) → motive (some (α, e₁, e₂))) →
((x : Option (Lean.Expr × Lean.Expr × Lean.Expr)) → motive x) → motive x | null | false |
Orientation.kahler._proof_1 | Mathlib.Analysis.InnerProductSpace.TwoDim | SMulCommClass ℝ ℝ ℂ | null | false |
_private.Mathlib.Order.Lattice.Nat.0.Nat.sInf_eq_zero._simp_1_4 | Mathlib.Order.Lattice.Nat | ∀ {p : ℕ → Prop} [inst : DecidablePred p] (h : ∃ n, p n), (Nat.find h = 0) = p 0 | null | false |
AddSubgroup.forall_mem_sup | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {C : Type u_2} [inst : AddCommGroup C] {s t : AddSubgroup C} {P : C → Prop},
(∀ x ∈ s ⊔ t, P x) ↔ ∀ x₁ ∈ s, ∀ x₂ ∈ t, P (x₁ + x₂) | null | true |
_private.Mathlib.GroupTheory.DoubleCoset.0.DoubleCoset.mem_doubleCoset_of_not_disjoint._simp_1_1 | Mathlib.GroupTheory.DoubleCoset | ∀ {α : Type u_2} [inst : Mul α] {s t : Set α} {a b : α},
(b ∈ DoubleCoset.doubleCoset a s t) = ∃ x ∈ s, ∃ y ∈ t, b = x * a * y | null | false |
Polynomial.modByMonic_eq_of_dvd_sub | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : CommRing R] {p₁ p₂ q : Polynomial R}, q.Monic → q ∣ p₁ - p₂ → p₁ %ₘ q = p₂ %ₘ q | null | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.readyForRatAdd_insert._proof_1_4 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | ∀ {n : ℕ} (i : ℕ), i + 1 ≤ { toList := [] }.size → i < { toList := [] }.size | null | false |
Char.utf8Size_eq_one_iff | Init.Data.String.Decode | ∀ {c : Char}, c.utf8Size = 1 ↔ c.val ≤ 127 | null | true |
Homotopy.noConfusion | Mathlib.Algebra.Homology.Homotopy | {P : Sort u_2} →
{ι : Type u_1} →
{V : Type u} →
{inst : CategoryTheory.Category.{v, u} V} →
{inst_1 : CategoryTheory.Preadditive V} →
{c : ComplexShape ι} →
{C D : HomologicalComplex V c} →
{f g : C ⟶ D} →
{t : Homotopy f g} →
{ι... | null | false |
Lean.Meta.Grind.TopSort.State.mk | Lean.Meta.Tactic.Grind.EqResolution | Std.HashSet Lean.Expr → Std.HashSet Lean.Expr → Array Lean.Expr → Lean.Meta.Grind.TopSort.State | null | true |
LinearMap.coe_smul | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R : Type u_1} {R₂ : Type u_3} {S : Type u_5} {M : Type u_8} {M₂ : Type u_10} [inst : Semiring R]
[inst_1 : Semiring R₂] [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M]
[inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂} [inst_6 : DistribSMul S M₂] [inst_7 : SMulCommClass R₂ S M₂] (a : S)
(f :... | null | true |
MulAction.IsMinimal.rec | Mathlib.Dynamics.Minimal | {M : Type u_1} →
{α : Type u_2} →
[inst : Monoid M] →
[inst_1 : TopologicalSpace α] →
[inst_2 : MulAction M α] →
{motive : MulAction.IsMinimal M α → Sort u} →
((dense_orbit : ∀ (x : α), Dense (MulAction.orbit M x)) → motive ⋯) →
(t : MulAction.IsMinimal M α) → mot... | null | false |
Complex.equivRealProdLm_symm_apply_im | Mathlib.LinearAlgebra.Complex.Module | ∀ (a : ℝ × ℝ), (Complex.equivRealProdLm.symm a).im = a.2 | null | true |
Set.mem_ite_empty_right._simp_1 | Mathlib.Data.Set.Basic | ∀ {α : Type u} (p : Prop) [inst : Decidable p] (t : Set α) (x : α), (x ∈ if p then t else ∅) = (p ∧ x ∈ t) | null | false |
CategoryTheory.SubmonoidFunctor.lift.congr_simp | Mathlib.CategoryTheory.Subfunctor.SubmonoidFunctor | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {M M' : CategoryTheory.Functor C MonCat} (p p_1 : M ⟶ M')
(e_p : p = p_1) (S' : CategoryTheory.SubmonoidFunctor M') (hp : CategoryTheory.SubmonoidFunctor.image p ⊤ ≤ S'),
CategoryTheory.SubmonoidFunctor.lift p S' hp = CategoryTheory.SubmonoidFunctor.lift p_1 ... | null | true |
Function.Exact.of_ladder_linearEquiv_of_exact | Mathlib.Algebra.Exact.Basic | ∀ {R : Type u_1} {M : Type u_2} {M' : Type u_3} {N : Type u_4} {N' : Type u_5} {P : Type u_6} {P' : Type u_7}
[inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M'] [inst_3 : AddCommMonoid N]
[inst_4 : AddCommMonoid N'] [inst_5 : AddCommMonoid P] [inst_6 : AddCommMonoid P'] [inst_7 : Module R M]... | null | true |
MeasureTheory.Measure.MutuallySingular.measure_compl_nullSet | Mathlib.MeasureTheory.Measure.MutuallySingular | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} (h : μ.MutuallySingular ν), ν h.nullSetᶜ = 0 | null | true |
Topology.IsClosedEmbedding.units_map | Mathlib.Topology.Algebra.Group.Basic | ∀ {α : Type u} {β : Type v} [inst : Monoid α] [inst_1 : TopologicalSpace α] [inst_2 : Monoid β]
[inst_3 : TopologicalSpace β] [ContinuousMul α] [T1Space α] {f : α →* β},
Topology.IsClosedEmbedding ⇑f → Topology.IsClosedEmbedding ⇑(Units.map f) | null | true |
_private.Mathlib.Algebra.Homology.ExactSequenceFour.0.CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles_hom_fac._proof_11 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {n : ℕ}
{S : CategoryTheory.ComposableArrows C (n + 3)},
S.Exact →
∀ (k : ℕ) (hk : autoParam (k ≤ n) CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles_hom_fac._auto_1),
CategoryTheory.CategoryStruc... | null | false |
_private.Mathlib.RingTheory.Ideal.Quotient.PowTransition.0.Submodule.factorPow_comp_powSMulQuotInclusion._proof_3 | Mathlib.RingTheory.Ideal.Quotient.PowTransition | ∀ {a b c d e : ℕ}, c = b + a → e = d + c → e = b + d + a | null | false |
_private.Lean.Meta.Tactic.Grind.Arith.FieldNormNum.0.Lean.Meta.Grind.Arith.FieldNormNum.Context.noConfusion | Lean.Meta.Tactic.Grind.Arith.FieldNormNum | {P : Sort u} →
{t t' : Lean.Meta.Grind.Arith.FieldNormNum.Context✝} →
t = t' → Lean.Meta.Grind.Arith.FieldNormNum.Context.noConfusionType✝ P t t' | null | false |
MeasureTheory.SimpleFunc.lintegralₗ._proof_1 | Mathlib.MeasureTheory.Function.SimpleFunc | IsScalarTower ENNReal ENNReal ENNReal | null | false |
SimpleGraph.decidableMemCommonNeighbors._aux_1 | Mathlib.Combinatorics.SimpleGraph.Basic | {V : Type u_1} →
(G : SimpleGraph V) → [DecidableRel G.Adj] → (v w : V) → DecidablePred fun x => x ∈ G.commonNeighbors v w | null | false |
Module.ringKrullDim_quotient_add_one_of_mem_nonZeroDivisors | Mathlib.RingTheory.KrullDimension.Regular | ∀ {R : Type u_1} [inst : CommRing R] [IsNoetherianRing R] {r : R},
r ∈ nonZeroDivisors R →
∀ {p : Ideal R} [p.IsPrime],
↑p.height = ringKrullDim R → r ∈ p → ringKrullDim (R ⧸ Ideal.span {r}) + 1 = ringKrullDim R | If `r` is a nonzerodivisor contained in an ideal of maximal height,
`dim (R / (r)) + 1 = dim R`. | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.AddSubMap.0.WeierstrassCurve._aux_Mathlib_AlgebraicGeometry_EllipticCurve_Affine_AddSubMap___delab_app__private_Mathlib_AlgebraicGeometry_EllipticCurve_Affine_AddSubMap_0_WeierstrassCurve_termS_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.AddSubMap | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
isSeqCompact_iff_seqCompactSpace | Mathlib.Topology.Compactness.CountablyCompact | ∀ {E : Type u_2} [inst : TopologicalSpace E] {A : Set E}, IsSeqCompact A ↔ SeqCompactSpace ↑A | null | true |
_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.Zipper.FinitenessRelation._simp_10 | Std.Data.DTreeMap.Internal.Zipper | ∀ (n : ℕ), (n < n + 1) = True | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.