name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Data.Json.FromToJson.Basic.0.Lean.Json.Structured.toJson.match_1 | Lean.Data.Json.FromToJson.Basic | (motive : Lean.Json.Structured → Sort u_1) →
(x : Lean.Json.Structured) →
((a : Array Lean.Json) → motive (Lean.Json.Structured.arr a)) →
((o : Std.TreeMap.Raw String Lean.Json compare) → motive (Lean.Json.Structured.obj o)) → motive x | null | false |
Aesop.PatSubstSource.casesOn | Aesop.Forward.State | {motive : Aesop.PatSubstSource → Sort u} →
(t : Aesop.PatSubstSource) →
((fvarId : Lean.FVarId) → motive (Aesop.PatSubstSource.hyp fvarId)) → motive Aesop.PatSubstSource.target → motive t | null | false |
_private.Std.Internal.Do.WP.Lemmas.0.EStateM.tryCatch.match_1.eq_2 | Std.Internal.Do.WP.Lemmas | ∀ {ε σ α : Type u_1} (motive : EStateM.Result ε σ α → Sort u_2) (ok : EStateM.Result ε σ α)
(h_1 : (e : ε) → (s : σ) → motive (EStateM.Result.error e s)) (h_2 : (ok : EStateM.Result ε σ α) → motive ok),
(∀ (e : ε) (s : σ), ok = EStateM.Result.error e s → False) →
(match ok with
| EStateM.Result.error e s ... | null | true |
LieHom.mem_idealRange_iff._simp_1 | Mathlib.Algebra.Lie.Ideal | ∀ {R : Type u} {L : Type v} {L' : Type w₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieRing L']
[inst_3 : LieAlgebra R L'] [inst_4 : LieAlgebra R L] (f : L →ₗ⁅R⁆ L'),
f.IsIdealMorphism → ∀ {y : L'}, (y ∈ f.idealRange) = ∃ x, f x = y | null | false |
CategoryTheory.SmallObject.SuccStruct.isColimitIterationCocone | Mathlib.CategoryTheory.SmallObject.TransfiniteIteration | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(Φ : CategoryTheory.SmallObject.SuccStruct C) →
(J : Type w) →
[inst_1 : LinearOrder J] →
[inst_2 : OrderBot J] →
[inst_3 : SuccOrder J] →
[inst_4 : WellFoundedLT J] →
[inst_5 : CategoryThe... | `Φ.iteration J` identifies to the colimit of `Φ.iterationFunctor J`. | true |
ULift.group._proof_6 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u_2} [inst : Group α] (x : ULift.{u_1, u_2} α) (x_1 : ℤ), Equiv.ulift (x ^ x_1) = Equiv.ulift (x ^ x_1) | null | false |
MeasureTheory.innerRegular_map_add_left | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : TopologicalSpace G] [BorelSpace G] {μ : MeasureTheory.Measure G}
[inst_3 : AddGroup G] [IsTopologicalAddGroup G] [μ.InnerRegular] (g : G),
(MeasureTheory.Measure.map (fun x => g + x) μ).InnerRegular | The image of an inner regular measure under left addition is again inner regular. | true |
WithBot.unbotD_zero | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Zero α] (d : α), WithBot.unbotD d 0 = 0 | null | true |
_private.Mathlib.Data.Fin.SuccPred.0.Fin.succAbove_succAbove_succAbove_predAbove._proof_1_11 | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} (i : Fin (n + 2)) (j : Fin (n + 1)) (k : Fin n),
↑j < ↑i → ¬↑k < ↑i - 1 → ¬↑k + 1 < ↑j → ↑k < ↑j → ↑k < ↑i → ↑k + 1 + 1 = ↑k | null | false |
_private.Mathlib.RingTheory.Support.0.Module.mem_support_iff_of_finite._simp_1_2 | Mathlib.RingTheory.Support | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (g : M)
(r : R), (r ∈ (R ∙ g).annihilator) = (r • g = 0) | null | false |
CategoryTheory.ObjectProperty.strictLimitsOfShape_monotone | Mathlib.CategoryTheory.ObjectProperty.LimitsOfShape | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P : CategoryTheory.ObjectProperty C} (J : Type u')
[inst_1 : CategoryTheory.Category.{v', u'} J] {Q : CategoryTheory.ObjectProperty C},
P ≤ Q → P.strictLimitsOfShape J ≤ Q.strictLimitsOfShape J | null | true |
HomologicalComplex.cylinder.map_ι₁_mapHomologicalComplexObjIso_hom | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_2}
{c : ComplexShape ι} (F : HomologicalComplex C c) [inst_2 : DecidableRel c.Rel] {D : Type u_3}
[inst_3 : CategoryTheory.Category.{v_2, u_3} D] [inst_4 : CategoryTheory.Preadditive D]
(H : Category... | null | true |
BddAbove.smul_of_nonpos | Mathlib.Algebra.Order.Module.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : Ring α] [inst_1 : PartialOrder α] [IsOrderedRing α] [inst_3 : AddCommGroup β]
[inst_4 : PartialOrder β] [IsOrderedAddMonoid β] [inst_6 : Module α β] [PosSMulMono α β] {s : Set β} {a : α},
a ≤ 0 → BddAbove s → BddBelow (a • s) | null | true |
Orientation.norm_div_tan_oangle_sub_left_of_oangle_eq_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Oriented.RightAngle | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [hd2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) {x y : V}, o.oangle x y = ↑(Real.pi / 2) → ‖y‖ / (o.oangle (x - y) x).tan = ‖x‖ | A side of a right-angled triangle divided by the tangent of the opposite angle equals the
adjacent side, version subtracting vectors. | true |
List.eraseIdx_modify_of_eq | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} (f : α → α) (i : ℕ) (l : List α), (l.modify i f).eraseIdx i = l.eraseIdx i | null | true |
ULift.ring._proof_3 | Mathlib.Algebra.Ring.ULift | ∀ {R : Type u_2} [inst : Ring R] (n : ℕ) (a : ULift.{u_1, u_2} R), ↑n.succ • a = ↑n • a + a | null | false |
AEMeasurable.cexp | Mathlib.MeasureTheory.Function.SpecialFunctions.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℂ},
AEMeasurable f μ → AEMeasurable (fun x => Complex.exp (f x)) μ | null | true |
NumberField.instCommRingInfiniteAdeleRing._aux_32 | Mathlib.NumberTheory.NumberField.InfiniteAdeleRing | (K : Type u_1) → [inst : Field K] → NumberField.InfiniteAdeleRing K → NumberField.InfiniteAdeleRing K | null | false |
Sym2.hrec._proof_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {motive : Sym2 α → Sort u_2} (f : (a b : α) → motive s(a, b)),
(∀ (a b : α), f a b ≍ f b a) →
∀ (a b : α × α),
Sym2.Rel α a b →
(match a with
| (a, b) => f a b) ≍
match b with
| (a, b) => f a b | null | false |
ValuationRing.instOfIsLocalRingOfIsBezout | Mathlib.RingTheory.Valuation.ValuationRing | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [IsLocalRing R] [IsBezout R], ValuationRing R | null | true |
RingHom.SurjectiveOnStalks.baseChange | Mathlib.RingTheory.SurjectiveOnStalks | ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_2} [inst_1 : CommRing S] {T : Type u_3} [inst_2 : CommRing T]
[inst_3 : Algebra R T] [inst_4 : Algebra R S],
(algebraMap R T).SurjectiveOnStalks → (algebraMap S (TensorProduct R S T)).SurjectiveOnStalks | null | true |
Int.bmod_eq_of_le_mul_two | Init.Data.Int.DivMod.Lemmas | ∀ {x : ℤ} {y : ℕ}, -↑y ≤ x * 2 → x * 2 < ↑y → x.bmod y = x | null | true |
Commute.conj | Mathlib.Algebra.Group.Commute.Basic | ∀ {G : Type u_1} [inst : Group G] {a b : G}, Commute a b → ∀ (h : G), Commute (h * a * h⁻¹) (h * b * h⁻¹) | null | true |
lp.instNormedSpace._proof_1 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {𝕜 : Type u_1} {α : Type u_3} {E : α → Type u_2} [inst : (i : α) → NormedAddCommGroup (E i)] [inst_1 : NormedField 𝕜]
[inst_2 : (i : α) → NormedSpace 𝕜 (E i)] (i : α), IsBoundedSMul 𝕜 (E i) | null | false |
ContinuousAffineMap.toContinuousMap_coe | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {P : Type u_4} {Q : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] (f : P →ᴬ[R] Q), ... | null | true |
PresheafOfModules.instMonoidalCompOppositeCommRingCatRingCatForget₂RingHomCarrierCarrierOpPushforward₀OfCommRingCat._proof_5 | Mathlib.Algebra.Category.ModuleCat.Presheaf.PushforwardZeroMonoidal | ∀ {C : Type u_2} {D : Type u_5} [inst : CategoryTheory.Category.{u_3, u_2} C]
[inst_1 : CategoryTheory.Category.{u_4, u_5} D] (F : CategoryTheory.Functor C D)
(R : CategoryTheory.Functor Dᵒᵖ CommRingCat)
(x : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))),
(CategoryTheory.MonoidalCateg... | null | false |
Lean.EnvironmentHeader._proof_1 | Lean.Environment | ∀ (modules : Array Lean.EffectiveImport), ∀ idx ∈ [:modules.size], idx < modules.size | null | false |
_private.Init.WFComputable.0.Acc.recC._unary._proof_6 | Init.WFComputable | ∀ {α : Sort u_1} {r : α → α → Prop} (y : (a : α) ×' Acc r a), Acc r y.1 | null | false |
Int.neg_le_neg | Init.Data.Int.Order | ∀ {a b : ℤ}, a ≤ b → -b ≤ -a | null | true |
Lean.MonadFileMap.noConfusion | Lean.Data.Position | {P : Sort u} →
{m : Type → Type} →
{t : Lean.MonadFileMap m} →
{m' : Type → Type} → {t' : Lean.MonadFileMap m'} → m = m' → t ≍ t' → Lean.MonadFileMap.noConfusionType P t t' | null | false |
String.Slice.Subslice.noConfusionType | Init.Data.String.Subslice | Sort u → {s : String.Slice} → s.Subslice → {s' : String.Slice} → s'.Subslice → Sort u | null | false |
CategoryTheory.GrothendieckTopology.Cover.Arrow.precomp_Y | Mathlib.CategoryTheory.Sites.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C}
{S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y), (I.precomp g).Y = Z | null | true |
Polynomial.aeval.eq_1 | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u} {A : Type z} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x : A),
Polynomial.aeval x = (Polynomial.aevalEquiv R A) x | null | true |
CategoryTheory.JointlyFaithful.map_injective | Mathlib.CategoryTheory.Functor.ReflectsIso.Jointly | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {I : Type u_2} {D : I → Type u_3}
[inst_1 : (i : I) → CategoryTheory.Category.{u_5, u_3} (D i)] {F : (i : I) → CategoryTheory.Functor C (D i)},
CategoryTheory.JointlyFaithful F → ∀ {X Y : C} {f g : X ⟶ Y}, (∀ (i : I), (F i).map f = (F i).map g) → f = g | null | true |
TopCat.Presheaf.isSheaf_on_punit_iff_isTerminal | Mathlib.Topology.Sheaves.PUnit | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (F : TopCat.Presheaf C ↧PUnit.{u_1 + 1}),
F.IsSheaf ↔ Nonempty (CategoryTheory.Limits.IsTerminal (F.obj (Opposite.op ⊥))) | null | true |
CategoryTheory.ShortComplex.homologyMap_smul | Mathlib.Algebra.Homology.ShortComplex.Linear | ∀ {R : Type u_1} {C : Type u_2} [inst : Semiring R] [inst_1 : CategoryTheory.Category.{v_1, u_2} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {S₁ S₂ : CategoryTheory.ShortComplex C}
(φ : S₁ ⟶ S₂) (a : R) [inst_4 : S₁.HasHomology] [inst_5 : S₂.HasHomology],
CategoryTheory.ShortCo... | null | true |
Nat.gcd_mul_left_sub_right | Init.Data.Nat.Gcd | ∀ {m n k : ℕ}, n ≤ m * k → m.gcd (m * k - n) = m.gcd n | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getValue_filter_not_contains._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] {l : List ((_ : α) × β)} {a : α}
(h : Std.Internal.List.containsKey a l = true),
some (Std.Internal.List.getValue a l h) = Std.Internal.List.getValue? a l | null | false |
Mathlib.Tactic.Translate.etaExpandN | Mathlib.Tactic.Translate.Core | ℕ → Lean.Expr → Lean.MetaM Lean.Expr | Eta expands `e` exactly `n` times. | true |
Cardinal.add_nat_inj | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {α β : Cardinal.{u_1}} (n : ℕ), α + ↑n = β + ↑n ↔ α = β | null | true |
_private.Mathlib.Topology.QuasiSeparated.0.QuasiSeparatedSpace.isCompact_sInter_of_nonempty._proof_1_6 | Mathlib.Topology.QuasiSeparated | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s : Set (Set α)},
s = {t | t ∈ s ∧ IsOpen t} ∪ {t | t ∈ s ∧ IsClosed t} → {t | t ∈ s ∧ IsOpen t} ⊆ s | null | false |
TopologicalSpace.OpenNhdsOf.rec | Mathlib.Topology.Sets.Opens | {α : Type u_2} →
[inst : TopologicalSpace α] →
{x : α} →
{motive : TopologicalSpace.OpenNhdsOf x → Sort u} →
((toOpens : TopologicalSpace.Opens α) →
(mem' : x ∈ toOpens.carrier) → motive { toOpens := toOpens, mem' := mem' }) →
(t : TopologicalSpace.OpenNhdsOf x) → motive t | null | false |
Lean.Parser.Tactic.Conv.pattern | Init.Conv | Lean.ParserDescr | * `pattern pat` traverses to the first subterm of the target that matches `pat`.
* `pattern (occs := *) pat` traverses to every subterm of the target that matches `pat`
which is not contained in another match of `pat`. It generates one subgoal for each matching
subterm.
* `pattern (occs := 1 2 4) pat` matches occur... | true |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.vietoris.specializes_iff_of_t1Space._simp_1_1 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s t : Set α}, s ⤳ t = ((∀ x ∈ s, ∃ y ∈ t, x ⤳ y) ∧ t ⊆ closure s) | null | false |
HomologicalComplex.Hom.comm_from | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ C₂ : HomologicalComplex V c}
(f : C₁.Hom C₂) (i : ι),
CategoryTheory.CategoryStruct.comp (f.f i) (C₂.dFrom i) = CategoryTheory.CategoryStruct.comp (C₁.dFrom i) (f.ne... | null | true |
StarMonoidHom.coe_one | Mathlib.Algebra.Star.MonoidHom | ∀ {A : Type u_2} [inst : Monoid A] [inst_1 : Star A], ⇑1 = id | null | true |
_private.Mathlib.AlgebraicGeometry.Morphisms.FlatRank.0.AlgebraicGeometry.Scheme.Hom.finrank.eq_1 | Mathlib.AlgebraicGeometry.Morphisms.FlatRank | ∀ {X S : AlgebraicGeometry.Scheme} (f : X ⟶ S) (s : ↥S),
AlgebraicGeometry.Scheme.Hom.finrank f s =
AlgebraicGeometry.IsAffine.finrank✝
(CategoryTheory.Limits.pullback.snd f (S.affineOpenCover.f (S.affineOpenCover.idx s))) (Exists.choose ⋯) | null | true |
Fin.xor_self | Mathlib.Data.Fin.Init | ∀ {k : ℕ} [inst : NeZero k] (a : Fin k), a ^^^ a = 0 | null | true |
_private.Mathlib.RingTheory.OreLocalization.NonZeroDivisors.0.OreLocalization.inv._simp_2 | Mathlib.RingTheory.OreLocalization.NonZeroDivisors | ∀ {a : Prop}, (a ∨ a) = a | null | false |
CategoryTheory.Bicategory.leftAdjointSquare.comp_hvcomp | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d e f x y z : B} {g₁ : a ⟶ d} {h₁ : b ⟶ e} {k₁ : c ⟶ f}
{g₂ : d ⟶ x} {h₂ : e ⟶ y} {k₂ : f ⟶ z} {l₁ : a ⟶ b} {l₂ : b ⟶ c} {l₃ : d ⟶ e} {l₄ : e ⟶ f} {l₅ : x ⟶ y} {l₆ : y ⟶ z}
(α : CategoryTheory.CategoryStruct.comp g₁ l₃ ⟶ CategoryTheory.CategoryStruct.comp l... | Horizontal and vertical composition of squares commutes. | true |
LieAlgebra.Basis.root_mem_or_mem_neg | Mathlib.Algebra.Lie.Basis.Base | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : CharZero K] [inst_2 : LieRing L] [inst_3 : LieAlgebra K L]
[inst_4 : FiniteDimensional K L] {H : LieSubalgebra K L} {ι : Type u_3} [inst_5 : Fintype ι]
(b : LieAlgebra.Basis ι H) [inst_6 : LieModule.IsTriangularizable K (↥H) L] [inst_7 : LieAlgebra.IsKillin... | null | true |
PowerSeries.derivative_invOf | Mathlib.RingTheory.PowerSeries.Derivative | ∀ {R : Type u_1} [inst : CommRing R] (f : PowerSeries R) [inst_1 : Invertible f],
PowerSeries.derivative ⅟f = -⅟f ^ 2 * PowerSeries.derivative f | null | true |
instModuleGradedTensorProduct._proof_4 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ (R : Type u_1) {ι : Type u_2} {A : Type u_3} {B : Type u_4} [inst : CommSemiring ι] [inst_1 : DecidableEq ι]
[inst_2 : CommRing R] [inst_3 : Ring A] [inst_4 : Ring B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(𝒜 : ι → Submodule R A) (ℬ : ι → Submodule R B) [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ... | null | false |
DerivedCategory.triangleOfSESδ._proof_3 | Mathlib.Algebra.Homology.DerivedCategory.ShortExact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{S : CategoryTheory.ShortComplex (CochainComplex C ℤ)} (i : ℤ),
(HomologicalComplex.sc (CochainComplex.mappingCone S.f) i).HasHomology | null | false |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.UnifyM.State.iPending | Lean.Meta.Sym.Pattern | Lean.Meta.Sym.UnifyM.State✝ → Array (Lean.Expr × Lean.Expr) | null | true |
Std.DHashMap.contains_of_contains_insertIfNew' | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [EquivBEq α] [LawfulHashable α]
{k a : α} {v : β k},
(m.insertIfNew k v).contains a = true → ¬((k == a) = true ∧ m.contains k = false) → m.contains a = true | This is a restatement of `contains_of_contains_insertIfNew` that is written to exactly match the proof
obligation in the statement of `get_insertIfNew`. | true |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.IsSlice | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | {M : Type u_1} → [Add M] → Set M → Prop | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey?_insertIfNew_le_minKey?._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Perfection.instCommMonoid | Mathlib.RingTheory.Perfection | (M : Type u_1) → [inst : CommMonoid M] → (p : ℕ) → CommMonoid (Perfection M p) | null | true |
_private.Init.Data.String.Lemmas.Pattern.String.Basic.0.String.Slice.Pattern.Model.ForwardSliceSearcher.isLongestRevMatchAt_iff._simp_1_1 | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {pos₁ pos₂ : s.Pos},
String.Slice.Pattern.Model.IsLongestRevMatchAt pat pos₁ pos₂ =
∃ (h : pos₁ ≤ pos₂), String.Slice.Pattern.Model.IsLongestRevMatch pat (pos₂.sliceTo pos₁ h) | null | false |
Finite.equivFinOfCardEq | Mathlib.SetTheory.Cardinal.NatCard | {α : Type u_1} → [Finite α] → {n : ℕ} → Nat.card α = n → α ≃ Fin n | Similar to `Finite.equivFin` but with control over the term used for the cardinality. | true |
NonUnitalSubring.center.instNonUnitalCommRing._proof_11 | Mathlib.RingTheory.NonUnitalSubring.Basic | ∀ (R : Type u_1) [inst : NonUnitalNonAssocRing R] (a : ↥(NonUnitalSubring.center R)), 0 * a = 0 | null | false |
_private.Mathlib.CategoryTheory.Generator.Basic.0.CategoryTheory.ObjectProperty.IsCoseparating.of_equivalence._simp_1_1 | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v_1, u₁} C] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v_2, u₂} D] (F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
{W : D} (h : F.obj Z ⟶ W),
CategoryTheory.CategoryStruct.comp (F.map f) (CategoryTheory.CategoryStruct.comp (F.map g) h) =
... | null | false |
WithTop.le_coe_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} {a : α} [inst : LE α] {x : WithTop α}, x ≤ ↑a ↔ ∃ b, x = ↑b ∧ b ≤ a | null | true |
LinearOrder.supClosed._simp_2 | Mathlib.Order.SupClosed | ∀ {α : Type u_3} [inst : LinearOrder α] (s : Set α), SupClosed s = True | null | false |
Option.bind.match_1 | Init.Data.Option.Basic | {α : Type u_1} →
{β : Type u_2} →
(motive : Option α → (α → Option β) → Sort u_3) →
(x : Option α) →
(x_1 : α → Option β) →
((x : α → Option β) → motive none x) → ((a : α) → (f : α → Option β) → motive (some a) f) → motive x x_1 | null | false |
IsNowhereDense.closure | Mathlib.Topology.GDelta.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsNowhereDense s → IsNowhereDense (closure s) | If a set `s` is nowhere dense, so is its closure. | true |
CategoryTheory.SimplicialObject.Homotopy.h_succ_comp_δ_castSucc_succ_assoc | Mathlib.AlgebraicTopology.SimplicialObject.Homotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.SimplicialObject C} {f g : X ⟶ Y}
(self : CategoryTheory.SimplicialObject.Homotopy f g) {n : ℕ} (j : Fin (n + 1)) {Z : C}
(h : Y.obj (Opposite.op { len := n + 1 }) ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.h j.succ) (CategoryTheor... | null | true |
CategoryTheory.Functor.PreservesEffectiveEpis.recOn | Mathlib.CategoryTheory.EffectiveEpi.Preserves | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{F : CategoryTheory.Functor C D} →
{motive : F.PreservesEffectiveEpis → Sort u} →
(t : F.PreservesEffectiveEpis) →
((preserves :
... | null | false |
Real.«term√_» | Mathlib.Analysis.Real.Sqrt | Lean.ParserDescr | The square root of a real number. This returns 0 for negative inputs.
This has notation `√x`. Note that `√x⁻¹` is parsed as `√(x⁻¹)`. | true |
UniformSpace.Completion.map_comp | Mathlib.Topology.UniformSpace.Completion | ∀ {α : Type u_1} [inst : UniformSpace α] {β : Type u_2} [inst_1 : UniformSpace β] {γ : Type u_3}
[inst_2 : UniformSpace γ] {g : β → γ} {f : α → β},
UniformContinuous g →
UniformContinuous f →
UniformSpace.Completion.map g ∘ UniformSpace.Completion.map f = UniformSpace.Completion.map (g ∘ f) | null | true |
MeasureTheory.Measure.join_zero | Mathlib.MeasureTheory.Measure.GiryMonad | ∀ {α : Type u_1} {mα : MeasurableSpace α}, MeasureTheory.Measure.join 0 = 0 | null | true |
OrderHom.instBotOfOrderBot | Mathlib.Order.Hom.Order | {α : Type u_1} → {β : Type u_2} → [inst : Preorder α] → [inst_1 : Preorder β] → [OrderBot β] → Bot (α →o β) | null | true |
Mathlib.Tactic.ClickSuggestions.spawnTask | Mathlib.Tactic.ClickSuggestions.SectionState | {α : Type} →
Mathlib.Tactic.ClickSuggestions.Premise →
Mathlib.Tactic.ClickSuggestions.ClickSuggestionsM α →
Mathlib.Tactic.ClickSuggestions.ClickSuggestionsM (Task (Except ProofWidgets.Html (Option α))) | Spawn a task that computes a piece of `Html` to be displayed when finished. | true |
Real.logb_nonpos_iff' | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {b x : ℝ}, 1 < b → 0 ≤ x → (Real.logb b x ≤ 0 ↔ x ≤ 1) | null | true |
Std.Internal.List.getValueCast_eraseKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {l : List ((a : α) × β a)} {k a : α}
{h : Std.Internal.List.containsKey a (Std.Internal.List.eraseKey k l) = true} (hl : Std.Internal.List.DistinctKeys l),
Std.Internal.List.getValueCast a (Std.Internal.List.eraseKey k l) h = Std.Internal.List.ge... | null | true |
continuous_cfcₙHom_of_cfcHom | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : Semifield R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : Ring A] [inst_6 : StarRing A]
[inst_7 : TopologicalSpace A] [inst_8 : Algebra R A] [inst_9 : ContinuousFunctionalCalculus R A p]... | null | true |
Int16.ne_of_lt | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, a < b → a ≠ b | null | true |
Lean.Meta.Try.Collector.OrdSet.rec | Lean.Meta.Tactic.Try.Collect | {α : Type} →
[inst : Hashable α] →
[inst_1 : BEq α] →
{motive : Lean.Meta.Try.Collector.OrdSet α → Sort u} →
((elems : Array α) → (set : Std.HashSet α) → motive { elems := elems, set := set }) →
(t : Lean.Meta.Try.Collector.OrdSet α) → motive t | null | false |
List.tailD_nil | Init.Data.List.Basic | ∀ {α : Type u} {l' : List α}, [].tailD l' = l' | null | true |
EuclideanGeometry.Sphere.mk_center | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {P : Type u_2} [inst : MetricSpace P] (c : P) (r : ℝ), { center := c, radius := r }.center = c | null | true |
SymAlg.instOne.eq_1 | Mathlib.Algebra.Symmetrized | ∀ {α : Type u_1} [inst : One α], SymAlg.instOne = { one := SymAlg.sym 1 } | null | true |
MvPolynomial.quotientEquivQuotientMvPolynomial._proof_1 | Mathlib.RingTheory.Polynomial.Quotient | ∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (I : Ideal R), (Ideal.map MvPolynomial.C I).IsTwoSided | null | false |
_private.Lean.Meta.Match.SimpH.0.Lean.Meta.Match.SimpH.isDone | Lean.Meta.Match.SimpH | Lean.Meta.Match.SimpH.M✝ Bool | null | true |
FP.Float.isFinite._sparseCasesOn_1 | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] →
{motive : FP.Float → Sort u} →
(t : FP.Float) →
((a : Bool) → (e : ℤ) → (m : ℕ) → (a_1 : FP.ValidFinite e m) → motive (FP.Float.finite a e m a_1)) →
(Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.Functor.IsCardinalAccessible.recOn | Mathlib.CategoryTheory.Presentable.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{κ : Cardinal.{w}} →
[inst_2 : Fact κ.IsRegular] →
{motive : F.IsCardinalAccessible κ → Sort u} →
... | null | false |
_private.Mathlib.Algebra.Lie.BaseChange.0.LieAlgebra.ExtendScalars.bracket'._proof_5 | Mathlib.Algebra.Lie.BaseChange | ∀ (R : Type u_1) (A : Type u_2) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A],
IsScalarTower R A (TensorProduct A A A) | null | false |
_private.Lean.Meta.Match.CaseValues.0.Lean.Meta.caseValues.loop._sparseCasesOn_3 | Lean.Meta.Match.CaseValues | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.Equivalence.congrLeft._proof_5 | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_6, u_5} C] {D : Type u_1}
[inst_1 : CategoryTheory.Category.{u_4, u_1} D] {E : Type u_3} [inst_2 : CategoryTheory.Category.{u_2, u_3} E]
(e : C ≌ D) (F : CategoryTheory.Functor C E),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor.whiskeringLe... | null | false |
Std.DTreeMap.Const.getD_alter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp] {k k' : α}
{fallback : β} {f : Option β → Option β},
Std.DTreeMap.Const.getD (Std.DTreeMap.Const.alter t k f) k' fallback =
if cmp k k' = Ordering.eq then (f (Std.DTreeMap.Const.get? t k)).getD fallback... | null | true |
BoundedOrderHom.dual._proof_3 | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : BoundedOrder α] [inst_2 : Preorder β]
[inst_3 : BoundedOrder β] (f : BoundedOrderHom αᵒᵈ βᵒᵈ), f.toFun ⊥ = ⊥ | null | false |
_private.Init.Omega.IntList.0.List.getElem?_zipWith.match_1.splitter | Init.Omega.IntList | {α : Type u_1} →
{β : Type u_2} →
(motive : Option α → Option β → Sort u_3) →
(x : Option α) →
(x_1 : Option β) →
((a : α) → (b : β) → motive (some a) (some b)) →
((x : Option α) →
(x_2 : Option β) → (∀ (a : α) (b : β), x = some a → x_2 = some b → False) → motiv... | null | true |
_private.Lean.Meta.MkIffOfInductiveProp.0.Lean.Meta.toInductive | Lean.Meta.MkIffOfInductiveProp | Lean.MVarId → List Lean.Name → List Lean.Expr → List Lean.Meta.Shape✝ → Lean.FVarId → Lean.MetaM Unit | Proves the right to left direction of a generated iff theorem.
| true |
Membership.mem.step | Init.Data.Range.Basic | ∀ {i : ℕ} {r : Std.Legacy.Range}, i ∈ r → (i - r.start) % r.step = 0 | null | true |
Set.preimage_const_mul_Ioi₀ | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {G₀ : Type u_2} [inst : CommGroupWithZero G₀] [inst_1 : PartialOrder G₀] [PosMulReflectLT G₀] {c : G₀} (a : G₀),
0 < c → (fun x => c * x) ⁻¹' Set.Ioi a = Set.Ioi (a / c) | null | true |
MeasureTheory.Measure.addHaar_smul_of_nonneg | Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
[FiniteDimensional ℝ E] (μ : MeasureTheory.Measure E) [μ.IsAddHaarMeasure] {r : ℝ},
0 ≤ r → ∀ (s : Set E), μ (r • s) = ENNReal.ofReal (r ^ Module.finrank ℝ E) * μ s | null | true |
Lean.Parser.Term.doIdbg.formatter | Lean.Parser.Do | Lean.PrettyPrinter.Formatter | null | true |
Lean.Doc.Block._sizeOf_inst | Lean.DocString.Types | (i : Type u) → (b : Type v) → [SizeOf i] → [SizeOf b] → SizeOf (Lean.Doc.Block i b) | null | false |
Int.tdiv_tmod_unique' | Init.Data.Int.DivMod.Lemmas | ∀ {a b r q : ℤ}, a ≤ 0 → b ≠ 0 → (a.tdiv b = q ∧ a.tmod b = r ↔ r + b * q = a ∧ -↑b.natAbs < r ∧ r ≤ 0) | null | true |
Path.Homotopy.symm₂._proof_3 | Mathlib.Topology.Homotopy.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x₀ x₁ : X} {p q : Path x₀ x₁} (F : p.Homotopy q) (x : ↑unitInterval),
F ((0, x).1, unitInterval.symm (0, x).2) = p.symm.toContinuousMap x | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.