name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
DividedPowers.mk.injEq | Mathlib.RingTheory.DividedPowers.Basic | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} (dpow : ℕ → A → A)
(dpow_null : ∀ {n : ℕ} {x : A}, x ∉ I → dpow n x = 0) (dpow_zero : ∀ {x : A}, x ∈ I → dpow 0 x = 1)
(dpow_one : ∀ {x : A}, x ∈ I → dpow 1 x = x) (dpow_mem : ∀ {n : ℕ} {x : A}, n ≠ 0 → x ∈ I → dpow n x ∈ I)
(dpow_add :
∀ {n : ℕ} {x y : A... | null | true |
_private.Mathlib.Algebra.Star.NonUnitalSubalgebra.0.NonUnitalStarAlgebra.coe_bot._simp_1_2 | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : NonUnitalSemiring A]
[inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : IsScalarTower R A A] [inst_6 : SMulCommClass R A A]
[inst_7 : StarModule R A] {x : A}, (x ∈ ⊥) = (x = 0) | null | false |
DomAddAct.instIsCancelAddOfAddOpposite | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} [inst : Add Mᵃᵒᵖ] [IsCancelAdd Mᵃᵒᵖ], IsCancelAdd Mᵈᵃᵃ | null | true |
Lean.Meta.Grind.AC.modify' | Lean.Meta.Tactic.Grind.AC.Util | (Lean.Meta.Grind.AC.State → Lean.Meta.Grind.AC.State) → Lean.Meta.Grind.GoalM Unit | null | true |
rTensor.toFun.congr_simp | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {P : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R P]
{f : M →ₗ[R] N} {g g_1 : N →ₗ[R] P} (e_g : g = g_1) (Q : Type u_5) [inst_7 : AddCommGroup ... | null | true |
Multiset.disjSum_mono_left | Mathlib.Data.Multiset.Sum | ∀ {α : Type u_1} {β : Type u_2} (t : Multiset β), Monotone fun s => s.disjSum t | null | true |
List.not_lt_of_mem_argmax | Mathlib.Data.List.MinMax | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder β] [inst_1 : DecidableLT β] {f : α → β} {l : List α} {a m : α},
a ∈ l → m ∈ List.argmax f l → ¬f m < f a | null | true |
CategoryTheory.ComposableArrows.map'_inv_eq_inv_map'._proof_2 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n m : ℕ}, n + 1 ≤ m → n ≤ m | null | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Types.0.Lean.Meta.Grind.Arith.Cutsat.initFn._@.Lean.Meta.Tactic.Grind.Arith.Cutsat.Types.1820690160._hygCtx._hyg.2 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | IO (Lean.Meta.Grind.SolverExtension Lean.Meta.Grind.Arith.Cutsat.State) | null | false |
MulAction.subsingleton_orbit_iff_mem_fixedPoints | Mathlib.GroupTheory.GroupAction.Basic | ∀ {M : Type u} [inst : Monoid M] {α : Type v} [inst_1 : MulAction M α] {a : α},
(MulAction.orbit M a).Subsingleton ↔ a ∈ MulAction.fixedPoints M α | null | true |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.byteIdx_offset_le_utf8ByteSize._simp_1_2 | Init.Data.String.Lemmas.Order | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁.byteIdx ≤ i₂.byteIdx) = (i₁ ≤ i₂) | null | false |
Commute.conj_iff | Mathlib.Algebra.Group.Commute.Basic | ∀ {G : Type u_1} [inst : Group G] {a b : G} (h : G), Commute (h * a * h⁻¹) (h * b * h⁻¹) ↔ Commute a b | null | true |
_private.Mathlib.Algebra.Lie.Loop.0.LieAlgebra.LoopAlgebra.twoCocycleOfBilinear._proof_5 | Mathlib.Algebra.Lie.Loop | ∀ (A : Type u_1) [inst : CommRing A] (a b c : A), a + b + c = 0 → a + b = -c | null | false |
RingHom.kerLift._proof_2 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Semiring S] (f : R →+* S), (RingHom.ker f).IsTwoSided | null | false |
_private.Mathlib.Data.Finset.Lattice.Lemmas.0.Finset.singleton_inter_of_notMem._simp_1_1 | Mathlib.Data.Finset.Lattice.Lemmas | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s₁ s₂ : Finset α}, (a ∈ s₁ ∩ s₂) = (a ∈ s₁ ∧ a ∈ s₂) | null | false |
MonoidHom.snd._proof_2 | Mathlib.Algebra.Group.Prod | ∀ (M : Type u_1) (N : Type u_2) [inst : MulOneClass M] [inst_1 : MulOneClass N] (x x_1 : M × N),
(x * x_1).2 = (x * x_1).2 | null | false |
Lean.Meta.Grind.Arith.CommRing.State.rings._default | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Array Lean.Meta.Grind.Arith.CommRing.CommRing | null | false |
Lean.Lsp.WorkDoneProgressReport.kind | Lean.Data.Lsp.Basic | Lean.Lsp.WorkDoneProgressReport → String | null | true |
Lean.Lsp.SemanticTokensParams.recOn | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SemanticTokensParams → Sort u} →
(t : Lean.Lsp.SemanticTokensParams) →
((textDocument : Lean.Lsp.TextDocumentIdentifier) → motive { textDocument := textDocument }) → motive t | null | false |
Colex.instSub.eq_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : Sub α], Colex.instSub = inst | null | true |
_private.Lean.Language.Basic.0.Lean.Language.Snapshot.Diagnostics.mk | Lean.Language.Basic | Lean.MessageLog → Option (IO.Ref (Option Dynamic)) → Lean.Language.Snapshot.Diagnostics | null | true |
HSub.mk | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → (α → β → γ) → HSub α β γ | null | true |
_private.Mathlib.Topology.Semicontinuity.Hemicontinuity.0.upperHemicontinuous_iff_forall_isOpen._simp_1_2 | Mathlib.Topology.Semicontinuity.Hemicontinuity | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → Set β} {x : α},
UpperHemicontinuousAt f x = ∀ (u : Set β), IsOpen u → f x ⊆ u → ∀ᶠ (x' : α) in nhds x, f x' ⊆ u | null | false |
_private.Lean.Environment.0.Lean.Environment.RealizeConstResult.noConfusion | Lean.Environment | {P : Sort u} →
{t t' : Lean.Environment.RealizeConstResult✝} → t = t' → Lean.Environment.RealizeConstResult.noConfusionType✝ P t t' | null | false |
Pi.instKleeneAlgebraForall._proof_4 | Mathlib.Algebra.Order.Kleene | ∀ {ι : Type u_1} {π : ι → Type u_2} [inst : (i : ι) → KleeneAlgebra (π i)] (x x_1 : (i : ι) → π i),
x_1 * x ≤ x_1 → ∀ (x_2 : ι), x_1 x_2 * KStar.kstar (x x_2) ≤ x_1 x_2 | null | false |
Vector.scanrM._proof_6 | Batteries.Data.Vector.Basic | ∀ {n : ℕ}, ∀ i ≤ n, 0 < i → n - i + 1 = n - (i - 1) | null | false |
Lean.Elab.Structural.IndGroupInfo.all | Lean.Elab.PreDefinition.Structural.IndGroupInfo | Lean.Elab.Structural.IndGroupInfo → Array Lean.Name | null | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toList_roc_add_add_eq_append._proof_1_2 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n k : ℕ}, ¬m + n + 1 ≤ m + n + k + 1 → False | null | false |
LieAlgebra.Prod.instLieRing._proof_4 | Mathlib.Algebra.Lie.Prod | ∀ {L₁ : Type u_1} {L₂ : Type u_2} [inst : LieRing L₁] [inst_1 : LieRing L₂] (x y z : L₁ × L₂),
(⁅x.1, (⁅y.1, z.1⁆, ⁅y.2, z.2⁆).1⁆, ⁅x.2, (⁅y.1, z.1⁆, ⁅y.2, z.2⁆).2⁆) =
(⁅(⁅x.1, y.1⁆, ⁅x.2, y.2⁆).1, z.1⁆, ⁅(⁅x.1, y.1⁆, ⁅x.2, y.2⁆).2, z.2⁆) +
(⁅y.1, (⁅x.1, z.1⁆, ⁅x.2, z.2⁆).1⁆, ⁅y.2, (⁅x.1, z.1⁆, ⁅x.2, z.2⁆).... | null | false |
CategoryTheory.Equivalence.precoherent_isSheaf_iff_of_essentiallySmall | Mathlib.CategoryTheory.Sites.Coherent.Equivalence | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Precoherent C] (A : Type u_3)
[inst_2 : CategoryTheory.Category.{v_3, u_3} A] [inst_3 : CategoryTheory.EssentiallySmall.{u_4, v_1, u_1} C]
(F : CategoryTheory.Functor Cᵒᵖ A),
CategoryTheory.Presheaf.IsSheaf (CategoryTheory.coh... | The coherent sheaf condition on an essentially small site can be checked after precomposing with
the equivalence with a small category.
| true |
Path.Homotopy.transAssoc._proof_3 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | Path.Homotopy.transAssocReparamAux 1 ∈ unitInterval | null | false |
Lean.IR.JoinPointId.mk.sizeOf_spec | Lean.Compiler.IR.Basic | ∀ (idx : Lean.IR.Index), sizeOf { idx := idx } = 1 + sizeOf idx | null | true |
TrivSqZeroExt.addMonoid._proof_6 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : AddMonoid R] [inst_1 : AddMonoid M],
autoParam
(∀ (n : ℕ) (x : TrivSqZeroExt R M),
TrivSqZeroExt.addMonoid._aux_3 (n + 1) x = TrivSqZeroExt.addMonoid._aux_3 n x + x)
AddMonoid.nsmul_succ._autoParam | null | false |
Std.DHashMap.Const.getD | Std.Data.DHashMap.Basic | {α : Type u} → {x : BEq α} → {x_1 : Hashable α} → {β : Type v} → (Std.DHashMap α fun x => β) → α → β → β | Tries to retrieve the mapping for the given key, returning `fallback` if no such mapping is present.
| true |
FP.Float.isFinite | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] → FP.Float → Bool | null | true |
Std.Tactic.BVDecide.BVPred.instToString | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ToString Std.Tactic.BVDecide.BVPred | null | true |
CategoryTheory.Comma.inhabited | Mathlib.CategoryTheory.Comma.Basic | {T : Type u₃} →
[inst : CategoryTheory.Category.{v₃, u₃} T] →
[Inhabited T] → Inhabited (CategoryTheory.Comma (CategoryTheory.Functor.id T) (CategoryTheory.Functor.id T)) | null | true |
Subtype.coe_mk | Mathlib.Data.Subtype | ∀ {α : Sort u_1} {p : α → Prop} (a : α) (h : p a), ↑⟨a, h⟩ = a | null | true |
BoundedContinuousFunction.instCStarAlgebra._proof_2 | Mathlib.Analysis.CStarAlgebra.ContinuousMap | ∀ {α : Type u_2} {A : Type u_1} [inst : TopologicalSpace α] [inst_1 : CStarAlgebra A],
CompleteSpace (BoundedContinuousFunction α A) | null | false |
bernsteinPolynomial.variance | Mathlib.RingTheory.Polynomial.Bernstein | ∀ (R : Type u_1) [inst : CommRing R] (n : ℕ),
∑ ν ∈ Finset.range (n + 1), (n • Polynomial.X - ↑ν) ^ 2 * bernsteinPolynomial R n ν =
n • Polynomial.X * (1 - Polynomial.X) | A certain linear combination of the previous three identities,
which we'll want later.
| true |
_private.Mathlib.Tactic.SplitIfs.0.Mathlib.Tactic.SplitPosition.hyp.inj | Mathlib.Tactic.SplitIfs | ∀ {fvarId fvarId_1 : Lean.FVarId},
Mathlib.Tactic.SplitPosition.hyp✝ fvarId = Mathlib.Tactic.SplitPosition.hyp✝ fvarId_1 → fvarId = fvarId_1 | null | true |
CategoryTheory.Comon.monoidal_tensorUnit_comon_counit | Mathlib.CategoryTheory.Monoidal.Comon_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C],
CategoryTheory.ComonObj.counit = CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) | null | true |
Module.Relations.Solution.ofQuotient_π | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] (relations : Module.Relations A),
(Module.Relations.Solution.ofQuotient relations).π = (Submodule.span A (Set.range relations.relation)).mkQ | null | true |
Lean.Grind.ToInt.Neg.toInt_neg | Init.Grind.ToInt | ∀ {α : Type u} {inst : Neg α} {I : outParam Lean.Grind.IntInterval} {inst_1 : Lean.Grind.ToInt α I}
[self : Lean.Grind.ToInt.Neg α I] (x : α), ↑(-x) = I.wrap (-↑x) | The embedding takes negation to negation, wrapped into the range interval. | true |
_private.Mathlib.CategoryTheory.Bicategory.Coherence.0.CategoryTheory.FreeBicategory.inclusionPathAux.match_1.eq_1 | Mathlib.CategoryTheory.Bicategory.Coherence | ∀ {B : Type u_2} [inst : Quiver B] {a : B} (motive : (x : B) → Quiver.Path a x → Sort u_3)
(h_1 : Unit → motive a Quiver.Path.nil) (h_2 : (x b : B) → (p : Quiver.Path a b) → (f : b ⟶ x) → motive x (p.cons f)),
(match a, Quiver.Path.nil with
| .(a), Quiver.Path.nil => h_1 ()
| x, p.cons f => h_2 x b p f) =
... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get!_insertMany_list_of_mem._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
ProofWidgets.instToJsonMakeEditLinkProps.toJson | ProofWidgets.Component.MakeEditLink | ProofWidgets.MakeEditLinkProps → Lean.Json | null | true |
Manifold.IsImmersionAtOfComplement.instNormedAddCommGroupSmallComplement._proof_27 | Mathlib.Geometry.Manifold.Immersion | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} {E'' : Type u_1} {F : Type u_4}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup E'']
[inst_4 : NormedSpace 𝕜 E''] [inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace 𝕜 F] {H : Type u_5}
[inst_7 : Topo... | null | false |
List.Nodup.insert | Mathlib.Data.List.Nodup | ∀ {α : Type u} {l : List α} {a : α} [inst : BEq α] [LawfulBEq α], l.Nodup → (List.insert a l).Nodup | null | true |
isEmpty_pprod | Mathlib.Logic.IsEmpty.Basic | ∀ {α : Sort u_1} {β : Sort u_2}, IsEmpty (α ×' β) ↔ IsEmpty α ∨ IsEmpty β | null | true |
IsDiscreteValuationRing.casesOn | Mathlib.RingTheory.DiscreteValuationRing.Basic | {R : Type u} →
[inst : CommRing R] →
[inst_1 : IsDomain R] →
{motive : IsDiscreteValuationRing R → Sort u_1} →
(t : IsDiscreteValuationRing R) →
([toIsPrincipalIdealRing : IsPrincipalIdealRing R] →
[toIsLocalRing : IsLocalRing R] → (not_a_field' : IsLocalRing.maximalIdeal R ≠... | null | false |
FiniteAddGrp.instCategory._proof_8 | Mathlib.Algebra.Category.Grp.FiniteGrp | autoParam
(∀ {X Y : FiniteAddGrp.{u_1}} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y) = f)
CategoryTheory.Category.comp_id._autoParam | null | false |
RelEmbedding.swap | Mathlib.Order.RelIso.Basic | {α : Type u_1} → {β : Type u_2} → {r : α → α → Prop} → {s : β → β → Prop} → r ↪r s → Function.swap r ↪r Function.swap s | A relation embedding is also a relation embedding between dual relations. | true |
LinearMap.restrictScalars | Mathlib.Algebra.Module.LinearMap.Defs | (R : Type u_1) →
{S : Type u_5} →
{M : Type u_8} →
{M₂ : Type u_10} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid M₂] →
[inst_4 : Module R M] →
[inst_5 : Module R M₂] →
... | If `M` and `M₂` are both `R`-modules and `S`-modules and `R`-module structures
are defined by an action of `R` on `S` (formally, we have two scalar towers), then any `S`-linear
map from `M` to `M₂` is `R`-linear.
See also `LinearMap.map_smul_of_tower`. | true |
Std.DTreeMap.Equiv.getEntryLE_eq.match_1 | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u_1} {β : α → Type u_2} {cmp : α → α → Ordering} {t₁ : Std.DTreeMap α β cmp} {k : α} (x : α)
(motive : x ∈ t₁ ∧ (cmp x k).isLE = true → Prop) (x_1 : x ∈ t₁ ∧ (cmp x k).isLE = true),
(∀ (h₁ : x ∈ t₁) (h₂ : (cmp x k).isLE = true), motive ⋯) → motive x_1 | null | false |
Equiv.sigmaSubtypeFiberEquiv | Mathlib.Logic.Equiv.Basic | {α : Type u_9} →
{β : Type u_10} → (f : α → β) → (p : β → Prop) → (∀ (x : α), p (f x)) → (y : Subtype p) × { x // f x = ↑y } ≃ α | If a predicate `p : β → Prop` is true on the range of a map `f : α → β`, then
`Σ y : {y // p y}, {x // f x = y}` is equivalent to `α`. | true |
BialgEquiv.ext | Mathlib.RingTheory.Bialgebra.Equiv | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : CoalgebraStruct R A] [inst_6 : CoalgebraStruct R B]
{e e' : A ≃ₐc[R] B}, (∀ (x : A), e x = e' x) → e = e' | null | true |
_private.Mathlib.RingTheory.PowerSeries.Evaluation.0.PowerSeries.HasEval.add._simp_1_1 | Mathlib.RingTheory.PowerSeries.Evaluation | ∀ {S : Type u_2} [inst : CommRing S] [inst_1 : TopologicalSpace S] {a : S},
PowerSeries.HasEval a = MvPowerSeries.HasEval fun x => a | null | false |
DedekindCut.instCompleteLinearOrder._proof_4 | Mathlib.Order.Completion | ∀ {α : Type u_1} [inst : LinearOrder α] (a b : DedekindCut α), Lattice.inf a b ≤ a | null | false |
BoundedContinuousFunction.mkOfDiscrete | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] →
[inst_1 : PseudoMetricSpace β] →
[DiscreteTopology α] →
(f : α → β) → (C : ℝ) → (∀ (x y : α), dist (f x) (f y) ≤ C) → BoundedContinuousFunction α β | If a function is bounded on a discrete space, it is automatically continuous,
and therefore gives rise to an element of the type of bounded continuous functions. | true |
CategoryTheory.Limits.coequalizerComparison._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u_4} {X Y : C} [inst : CategoryTheory.Category.{u_3, u_4} C] (f g : X ⟶ Y) {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (G : CategoryTheory.Functor C D)
[inst_2 : CategoryTheory.Limits.HasCoequalizer f g],
CategoryTheory.CategoryStruct.comp (G.map f) (G.map (CategoryTheory.Limits.coe... | null | false |
GaloisCoinsertion.ofDual._proof_3 | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] {l : αᵒᵈ → βᵒᵈ} {u : βᵒᵈ → αᵒᵈ}
(x : GaloisCoinsertion l u) (a : βᵒᵈ) (h : a ≤ l (u a)), x.choice a h = u a | null | false |
DivisionSemiring.zpow_succ' | Mathlib.Algebra.Field.Defs | ∀ {K : Type u_2} [self : DivisionSemiring K] (n : ℕ) (a : K),
DivisionSemiring.zpow (↑n.succ) a = DivisionSemiring.zpow (↑n) a * a | `a ^ (n + 1) = a ^ n * a` | true |
Std.DHashMap.Internal.Raw₀.getKey_insertMany_emptyWithCapacity_list_of_mem | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α]
{l : List ((a : α) × β a)} {k k' : α},
(k == k') = true →
List.Pairwise (fun a b => (a.fst == b.fst) = false) l →
k ∈ List.map Sigma.fst l →
∀ {h' : (↑(Std.DHashMap.Internal.Raw₀.emptyWithCapacity.... | null | true |
Lean.PrettyPrinter.Parenthesizer.instCoeForallForallParenthesizerAliasValue | Lean.PrettyPrinter.Parenthesizer | Coe (Lean.PrettyPrinter.Parenthesizer → Lean.PrettyPrinter.Parenthesizer → Lean.PrettyPrinter.Parenthesizer)
Lean.PrettyPrinter.Parenthesizer.ParenthesizerAliasValue | null | true |
_private.Init.Data.Dyadic.Round.0.Dyadic.roundDown_le.match_1_3 | Init.Data.Dyadic.Round | ∀ (motive : ℤ → Prop) (x : ℤ),
(∀ (l : ℕ), x = Int.ofNat l → motive (Int.ofNat l)) →
(∀ (a : ℕ), x = Int.negSucc a → motive (Int.negSucc a)) → motive x | null | false |
Std.DTreeMap.Internal.Impl.equiv_iff_toList_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t₁.WF → t₂.WF → (t₁.Equiv t₂ ↔ t₁.toList = t₂.toList) | null | true |
Std.Do.PredTrans.Conjunctive | Std.Do.PredTrans | {ps : Std.Do.PostShape} → {α : Type u} → (Std.Do.PostCond α ps → Std.Do.Assertion ps) → Prop | Transforming a conjunction of postconditions is the same as the conjunction of transformed
postconditions.
| true |
Lean.DataValue.ofString.inj | Lean.Data.KVMap | ∀ {v v_1 : String}, Lean.DataValue.ofString v = Lean.DataValue.ofString v_1 → v = v_1 | null | true |
Lean.Parser.«command__Builtin_simproc__[_]_(_):=_» | Init.Simproc | Lean.ParserDescr | A builtin simplification procedure.
| true |
Multiset.coe_foldl | Mathlib.Data.Multiset.MapFold | ∀ {α : Type u_1} {β : Type v} (f : β → α → β) [inst : RightCommutative f] (b : β) (l : List α),
Multiset.foldl f b ↑l = List.foldl f b l | null | true |
UInt64.ofFin_mod | Init.Data.UInt.Lemmas | ∀ (a b : Fin UInt64.size), UInt64.ofFin (a % b) = UInt64.ofFin a % UInt64.ofFin b | null | true |
integral_cos_sq_sub_sin_sq | Mathlib.Analysis.SpecialFunctions.Integrals.Basic | ∀ {a b : ℝ}, ∫ (x : ℝ) in a..b, Real.cos x ^ 2 - Real.sin x ^ 2 = Real.sin b * Real.cos b - Real.sin a * Real.cos a | null | true |
CategoryTheory.Comma.mapFst_inv_app | 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] {A' : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} A'] {B' : Type u₅} [inst_4 : CategoryTheory.Category.{v₅, u₅} B']
{T' : Type... | null | true |
egauge_smul_left | Mathlib.Analysis.Convex.EGauge | ∀ {𝕜 : Type u_1} [inst : NormedDivisionRing 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E] {c : 𝕜},
c ≠ 0 → ∀ (s : Set E) (x : E), egauge 𝕜 (c • s) x = egauge 𝕜 s x / ‖c‖ₑ | null | true |
Function.Exact.rangeFactorization | Mathlib.Algebra.Exact.Basic | ∀ {M : Type u_2} {N : Type u_4} {P : Type u_6} {f : M → N} {g : N → P} [inst : Zero P],
Function.Exact f g → ∀ (hg : 0 ∈ Set.range g), Function.Exact Subtype.val (Set.rangeFactorization g) | If two maps `f : M → N` and `g : N → P` are exact, then the induced maps
`Set.range f → N → Set.range g` are exact.
Note that if you already have an instance `[Zero (Set.range g)]` (which is unlikely) this lemma
may not apply if the zero of `Set.range g` is not definitionally equal to `⟨0, hg⟩`. | true |
StieltjesFunction.measure_Icc | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (f : StieltjesFunction R)
[inst_2 : OrderTopology R] [inst_3 : CompactIccSpace R] [inst_4 : MeasurableSpace R] [inst_5 : BorelSpace R]
[inst_6 : SecondCountableTopology R] [inst_7 : DenselyOrdered R] (a b : R),
f.measure (Set.Icc a b) = ENNReal... | null | true |
SSet.PtSimplex.relStructCastSuccEquivMulStruct._proof_16 | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {X : SSet} {n : ℕ} {x : X.obj (Opposite.op { len := 0 })} {f g : X.PtSimplex n x} {i : Fin n}
(h : SSet.PtSimplex.MulStruct SSet.RelativeMorphism.const f g i) (j : Fin (n + 2)),
i.castSucc.succ < j → CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ j) h.map = SSet.const x | null | false |
Quaternion.normSq_intCast._simp_1 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (z : ℤ), ↑z ^ 2 = Quaternion.normSq ↑z | null | false |
Lean.Meta.Sym.dsimp.match_1 | Lean.Meta.Sym.DSimp.DSimpM | (motive : Lean.Meta.Sym.DSimp.Result → Sort u_1) →
(__do_lift : Lean.Meta.Sym.DSimp.Result) →
((done : Bool) → motive (Lean.Meta.Sym.DSimp.Result.rfl done)) →
((e' : Lean.Expr) → (done : Bool) → motive (Lean.Meta.Sym.DSimp.Result.step e' done)) → motive __do_lift | null | false |
FreeAddGroup.Red.Step.not_rev._simp_1 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L₁ L₂ : List (α × Bool)} {x : α} {b : Bool},
FreeAddGroup.Red.Step (L₁ ++ (x, !b) :: (x, b) :: L₂) (L₁ ++ L₂) = True | null | false |
CompHausLike.LocallyConstant.presheaf_ext | Mathlib.Condensed.Discrete.LocallyConstant | ∀ {P : TopCat → Prop} [inst : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)]
{S : CompHausLike P} {Y : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w))}
[inst_1 : CompHausLike.HasProp P PUnit.{u + 1}]
(f : LocallyConstant (↑S.toTop) (Y.obj (Opposite.op (CompHausLike.of... | To check equality of two elements of `X(S)`, it suffices to check equality after composing with
each `X(S) → X(Sᵢ)`.
| true |
LinearAlgebra.FreeProduct.lift_unique | Mathlib.LinearAlgebra.FreeProduct.Basic | ∀ {I : Type u} [inst : DecidableEq I] (R : Type v) [inst_1 : CommSemiring R] (A : I → Type w)
[inst_2 : (i : I) → Semiring (A i)] [inst_3 : (i : I) → Algebra R (A i)] {B : Type w'} [inst_4 : Semiring B]
[inst_5 : Algebra R B] (maps : {i : I} → A i →ₐ[R] B) (f : LinearAlgebra.FreeProduct R A →ₐ[R] B),
(∀ (i : I), ... | null | true |
RingNormClass.casesOn | Mathlib.Algebra.Order.Hom.Basic | {F : Type u_7} →
{α : Type u_8} →
{β : Type u_9} →
[inst : NonUnitalNonAssocRing α] →
[inst_1 : Semiring β] →
[inst_2 : PartialOrder β] →
[inst_3 : FunLike F α β] →
{motive : RingNormClass F α β → Sort u} →
(t : RingNormClass F α β) →
... | null | false |
_private.Init.Data.Array.BasicAux.0.Array.mapM'.go._unsafe_rec | Init.Data.Array.BasicAux | {m : Type u_1 → Type u_2} →
{α : Type u_3} →
{β : Type u_1} →
[Monad m] →
(α → m β) → (as : Array α) → (i : ℕ) → { bs // bs.size = i } → i ≤ as.size → m { bs // bs.size = as.size } | null | false |
RootPairingCat.mk | Mathlib.LinearAlgebra.RootSystem.RootPairingCat | {R : Type u} →
[inst : CommRing R] →
(weight : Type v) →
[weightIsAddCommGroup : AddCommGroup weight] →
[weightIsModule : Module R weight] →
(coweight : Type v) →
[coweightIsAddCommGroup : AddCommGroup coweight] →
[coweightIsModule : Module R coweight] →
... | null | true |
Lean.Environment.PromiseCheckedResult.mainEnv | Lean.Environment | Lean.Environment.PromiseCheckedResult → Lean.Environment | Resulting "main branch" environment. Accessing the kernel environment will block until
`PromiseCheckedResult.commitChecked` has been called.
| true |
LightProfinite.Extend.functor._proof_4 | Mathlib.Topology.Category.LightProfinite.Extend | ∀ {F : CategoryTheory.Functor ℕᵒᵖ FintypeCat} (c : CategoryTheory.Limits.Cone (F.comp FintypeCat.toLightProfinite))
{X Y Z : ℕᵒᵖ} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.StructuredArrow.homMk (F.map (CategoryTheory.CategoryStruct.comp f g)) ⋯ =
CategoryTheory.CategoryStruct.comp (CategoryTheory.StructuredArrow.... | null | false |
BitVec.or_allOnes | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, x ||| BitVec.allOnes w = BitVec.allOnes w | null | true |
_private.Mathlib.FieldTheory.Galois.Basic.0.IsGalois.map_fixingSubgroup._simp_1_1 | Mathlib.FieldTheory.Galois.Basic | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | null | false |
Mathlib.Tactic.Sat._aux_Mathlib_Tactic_Sat_FromLRAT___elabRules_Mathlib_Tactic_Sat_commandLrat_proof_Example_____1 | Mathlib.Tactic.Sat.FromLRAT | Lean.Elab.Command.CommandElab | A macro for producing SAT proofs from CNF / LRAT files.
These files are commonly used in the SAT community for writing proofs.
The input to the `lrat_proof` command is the name of the theorem to define,
and the statement (written in CNF format) and the proof (in LRAT format).
For example:
```
lrat_proof foo
"p cnf 2... | false |
UInt64.instCommMonoid | Mathlib.Data.UInt | CommMonoid UInt64 | null | true |
Mathlib.Tactic.BicategoryLike.eval._sunfold | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {ρ : Type} →
[Mathlib.Tactic.BicategoryLike.MonadMor₁ (Mathlib.Tactic.BicategoryLike.CoherenceM ρ)] →
[Mathlib.Tactic.BicategoryLike.MonadMor₂Iso (Mathlib.Tactic.BicategoryLike.CoherenceM ρ)] →
[Mathlib.Tactic.BicategoryLike.MonadNormalExpr (Mathlib.Tactic.BicategoryLike.CoherenceM ρ)] →
[Mathlib.Ta... | null | false |
Quaternion.re_im | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (a : Quaternion R), a.im.re = 0 | null | true |
_private.Mathlib.Data.List.Cycle.0.Cycle.Subsingleton.nodup._simp_1_2 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {l : List α}, (l.length = 0) = (l = []) | null | false |
Polynomial.iterate_derivative_natCast_mul | Mathlib.Algebra.Polynomial.Derivative | ∀ {R : Type u} [inst : Semiring R] {n k : ℕ} {f : Polynomial R},
(⇑Polynomial.derivative)^[k] (↑n * f) = ↑n * (⇑Polynomial.derivative)^[k] f | null | true |
_private.Mathlib.Geometry.Euclidean.Sphere.Tangent.0.EuclideanGeometry.Sphere.isIntTangent_iff_dist_center._simp_1_9 | Mathlib.Geometry.Euclidean.Sphere.Tangent | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | null | false |
_private.Mathlib.Analysis.Calculus.ContDiff.Defs.0.contDiff_iff_contDiffAt._simp_1_1 | 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] {f : E → F}
{n : WithTop ℕ∞}, ContDiff 𝕜 n f = ContDiffOn 𝕜 n f Set.univ | null | false |
CategoryTheory.GrothendieckTopology.instCompleteLattice._proof_5 | Mathlib.CategoryTheory.Sites.Grothendieck | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (a b c : CategoryTheory.GrothendieckTopology C),
a ≤ c →
b ≤ c →
{ sieves := sInf (CategoryTheory.GrothendieckTopology.sieves '' {x | a ≤ x ∧ b ≤ x}), top_mem' := ⋯,
pullback_stable' := ⋯, transitive' := ⋯ } ≤
c | null | false |
AddAction.IsPreprimitive.isCoatom_stabilizer_of_isPreprimitive | Mathlib.GroupTheory.GroupAction.Primitive | ∀ (G : Type u_3) [inst : AddGroup G] {X : Type u_4} [inst_1 : AddAction G X] [Nontrivial X]
[AddAction.IsPreprimitive G X] (a : X), IsCoatom (AddAction.stabilizer G a) | In a preprimitive action, stabilizers are maximal subgroups. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.