name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.SetTheory.Lists.0.Lists'.ofList_subset._simp_1_1 | Mathlib.SetTheory.Lists | ∀ {α : Type u_1} {a : α} {l m : List α}, (a :: l ⊆ m) = (a ∈ m ∧ l ⊆ m) | false |
WithIdealFilter.idealSet | Mathlib.RingTheory.IdealFilter.Topology | {A : Type u_1} → [inst : Ring A] → {F : IdealFilter A} → Ideal A → Set (WithIdealFilter F) | true |
_private.Std.Data.ExtDHashMap.Lemmas.0.Std.ExtDHashMap.Const.ofList_eq_empty_iff._simp_1_1 | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], (m = ∅) = (m.isEmpty = true) | false |
WeierstrassCurve.exists_isMinimal | Mathlib.AlgebraicGeometry.EllipticCurve.Reduction | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsDiscreteValuationRing R] {K : Type u_2}
[inst_3 : Field K] [inst_4 : Algebra R K] [inst_5 : IsFractionRing R K] (W : WeierstrassCurve K),
∃ C, WeierstrassCurve.IsMinimal R (C • W) | true |
_private.Mathlib.Order.Filter.Map.0.Filter.comap_neBot_iff_frequently._simp_1_4 | Mathlib.Order.Filter.Map | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {p : β → Prop}, (∃ b, (∃ a, f a = b) ∧ p b) = ∃ a, p (f a) | false |
TensorProduct.congr_refl_refl | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_7} {N : Type u_8} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N],
TensorProduct.congr (LinearEquiv.refl R M) (LinearEquiv.refl R N) = LinearEquiv.refl R (TensorProduct R M N) | true |
SmoothBumpCovering.noConfusion | Mathlib.Geometry.Manifold.PartitionOfUnity | {P : Sort u} →
{ι : Type uι} →
{E : Type uE} →
{inst : NormedAddCommGroup E} →
{inst_1 : NormedSpace ℝ E} →
{H : Type uH} →
{inst_2 : TopologicalSpace H} →
{I : ModelWithCorners ℝ E H} →
{M : Type uM} →
{inst_3 : TopologicalSpace ... | false |
ForIn.recOn | Init.Core | {m : Type u₁ → Type u₂} →
{ρ : Type u} →
{α : Type v} →
{motive : ForIn m ρ α → Sort u_1} →
(t : ForIn m ρ α) →
((forIn : {β : Type u₁} → ρ → β → (α → β → m (ForInStep β)) → m β) → motive { forIn := forIn }) → motive t | false |
DFinsupp.sigmaCurryLEquiv._proof_3 | Mathlib.LinearAlgebra.DFinsupp | ∀ {ι : Type u_3} [inst : DecidableEq ι] {α : ι → Type u_2} {M : (i : ι) → α i → Type u_1}
[inst_1 : (i : ι) → (j : α i) → AddCommMonoid (M i j)],
Function.LeftInverse DFinsupp.sigmaCurryEquiv.invFun DFinsupp.sigmaCurryEquiv.toFun | false |
IsCompact.bddAbove_image | Mathlib.Topology.Order.Compact | ∀ {α : Type u_2} {β : Type u_3} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : TopologicalSpace β]
[ClosedIciTopology α] [Nonempty α] {f : β → α} {K : Set β}, IsCompact K → ContinuousOn f K → BddAbove (f '' K) | true |
String.Pos.startPos_lt_iff | Init.Data.String.Lemmas.Order | ∀ {s : String} (p : s.Pos), s.startPos < p ↔ p ≠ s.startPos | true |
StarSubalgebra.isClosedEmbedding_inclusion | Mathlib.Topology.Algebra.StarSubalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : TopologicalSpace A]
[inst_3 : Semiring A] [inst_4 : Algebra R A] [inst_5 : StarRing A] [inst_6 : StarModule R A]
{S₁ S₂ : StarSubalgebra R A} (h : S₁ ≤ S₂), IsClosed ↑S₁ → Topology.IsClosedEmbedding ⇑(StarSubalgebra.inclusion h) | true |
Algebra.IsStandardSmoothOfRelativeDimension.baseChange | Mathlib.RingTheory.Smooth.StandardSmooth | ∀ (n : ℕ) {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (T : Type u_1)
[inst_3 : CommRing T] [inst_4 : Algebra R T] [Algebra.IsStandardSmoothOfRelativeDimension n R S],
Algebra.IsStandardSmoothOfRelativeDimension n T (TensorProduct R T S) | true |
_private.Std.Sat.AIG.RelabelNat.0.Std.Sat.AIG.RelabelNat.State.Inv2.property._proof_1 | Std.Sat.AIG.RelabelNat | ∀ {α : Type} (decls : Array (Std.Sat.AIG.Decl α)) (idx upper : ℕ),
idx < upper → upper ≤ decls.size → ¬idx < decls.size → False | false |
MulRingNorm.mulRingNormEquivAbsoluteValue | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | {R : Type u_2} → [inst : Ring R] → [Nontrivial R] → MulRingNorm R ≃ AbsoluteValue R ℝ | true |
Lean.JsonRpc.ResponseError.mk | Lean.Data.JsonRpc | {α : Type u} → Lean.JsonRpc.RequestID → Lean.JsonRpc.ErrorCode → String → Option α → Lean.JsonRpc.ResponseError α | true |
Subgroup.isComplement_iff_existsUnique | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : Group G] {S T : Set G}, Subgroup.IsComplement S T ↔ ∀ (g : G), ∃! x, ↑x.1 * ↑x.2 = g | true |
_private.Mathlib.RingTheory.Polynomial.Quotient.0.Ideal.eq_zero_of_polynomial_mem_map_range._simp_1_1 | Mathlib.RingTheory.Polynomial.Quotient | ∀ {R : Type u} [inst : Ring R] {I : Ideal R} {a : R} [inst_1 : I.IsTwoSided], ((Ideal.Quotient.mk I) a = 0) = (a ∈ I) | false |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.StructId.0.Lean.Meta.Grind.Arith.Linear.isCutsatType | Lean.Meta.Tactic.Grind.Arith.Linear.StructId | Lean.Expr → Lean.Meta.Grind.GoalM Bool | true |
cast_inj._simp_1 | Mathlib.Logic.Function.Basic | ∀ {α β : Type u} (h : α = β) {x y : α}, (cast h x = cast h y) = (x = y) | false |
TensorProduct.tensorTensorTensorComm_trans_tensorTensorTensorComm | Mathlib.LinearAlgebra.TensorProduct.Associator | ∀ (R : Type u_1) [inst : CommSemiring R] {M : Type u_5} {N : Type u_6} {P : Type u_7} {Q : Type u_8}
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : AddCommMonoid Q]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R Q] [inst_8 : Module R P],
TensorProduct.te... | true |
_private.Lean.Elab.MacroArgUtil.0.Lean.Elab.Command.expandMacroArg.mkAntiquotNode._sparseCasesOn_4 | Lean.Elab.MacroArgUtil | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
motive Lean.Name.anonymous →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 3 t.ctorIdx → motive t) → motive t | false |
Matroid.isBasis_iff_isBasis_closure_of_subset._auto_1 | Mathlib.Combinatorics.Matroid.Closure | Lean.Syntax | false |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic.0.CFC.isUnit_sqrt_iff_isStrictlyPositive._proof_1_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst_1 : Ring A] [inst_5 : Algebra ℝ A], SMulCommClass ℝ A A | false |
CategoryTheory.StrictlyUnitaryPseudofunctorCore.map₂_whisker_right | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(self : CategoryTheory.StrictlyUnitaryPseudofunctorCore B C) {a b c : B} {f g : a ⟶ b} (η : f ⟶ g) (h : b ⟶ c),
self.map₂ (CategoryTheory.Bicategory.whiskerRight η h) =
CategoryTheory.CategoryStruct.comp (s... | true |
_private.Mathlib.Probability.Process.Stopping.0.MeasureTheory.IsStoppingTime.measurableSpace_const._simp_1_1 | Mathlib.Probability.Process.Stopping | ∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True | false |
Lean.Lsp.LeanFileProgressParams.noConfusionType | Lean.Data.Lsp.Extra | Sort u → Lean.Lsp.LeanFileProgressParams → Lean.Lsp.LeanFileProgressParams → Sort u | false |
Subsemiring.map_comap_eq | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (f : R →+* S) (t : Subsemiring S),
Subsemiring.map f (Subsemiring.comap f t) = t ⊓ f.rangeS | true |
Homotopy.mkCoinductive | Mathlib.Algebra.Homology.Homotopy | {V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Preadditive V] →
{P Q : CochainComplex V ℕ} →
(e : P ⟶ Q) →
(zero : P.X 1 ⟶ Q.X 0) →
e.f 0 = CategoryTheory.CategoryStruct.comp (P.d 0 1) zero →
(one : P.X 2 ⟶ Q.X 1) →
... | true |
WithLp.continuous_snd | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (α : Type u_2) (β : Type u_3) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β],
Continuous WithLp.snd | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.SolverExtension.mk._flat_ctor | Lean.Meta.Tactic.Grind.Types | {σ : Type} →
ℕ →
IO σ →
(Lean.Expr → Option Lean.Expr → Lean.Meta.Grind.GoalM Unit) →
(Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Unit) →
(Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Unit) →
Lean.Meta.Grind.GoalM Bool →
Lean.Meta.Grind.Action →
... | false |
_private.Lean.Meta.MethodSpecs.0.Lean.getMethodSpecsInfo.match_6 | Lean.Meta.MethodSpecs | (motive : Option Lean.StructureInfo → Sort u_1) →
(x : Option Lean.StructureInfo) →
((structInfo : Lean.StructureInfo) → motive (some structInfo)) →
((x : Option Lean.StructureInfo) → motive x) → motive x | false |
Lean.Widget.RpcEncodablePacket.widget.inj._@.Lean.Server.FileWorker.WidgetRequests.2377472685._hygCtx._hyg.1 | Lean.Server.FileWorker.WidgetRequests | ∀ {wi alt wi_1 alt_1 : Lean.Json},
Lean.Widget.RpcEncodablePacket.widget✝ wi alt = Lean.Widget.RpcEncodablePacket.widget✝ wi_1 alt_1 →
wi = wi_1 ∧ alt = alt_1 | false |
MeasureTheory.MeasureSpace.toMeasurableSpace | Mathlib.MeasureTheory.Measure.MeasureSpaceDef | {α : Type u_6} → [self : MeasureTheory.MeasureSpace α] → MeasurableSpace α | true |
BddOrd.dualEquiv_inverse | Mathlib.Order.Category.BddOrd | BddOrd.dualEquiv.inverse = BddOrd.dual | true |
PresheafOfModules.Derivation.ext_iff | Mathlib.Algebra.Category.ModuleCat.Differentials.Presheaf | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {D : Type u₂} {inst_1 : CategoryTheory.Category.{v₂, u₂} D}
{S : CategoryTheory.Functor Cᵒᵖ CommRingCat} {F : CategoryTheory.Functor C D}
{R : CategoryTheory.Functor Dᵒᵖ CommRingCat}
{M : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat Ring... | true |
_private.Mathlib.Algebra.MvPolynomial.SchwartzZippel.0.«_aux_Mathlib_Algebra_MvPolynomial_SchwartzZippel___macroRules__private_Mathlib_Algebra_MvPolynomial_SchwartzZippel_0_term_^^__1» | Mathlib.Algebra.MvPolynomial.SchwartzZippel | Lean.Macro | false |
TopologicalSpace.CompactOpens.ctorIdx | Mathlib.Topology.Sets.Compacts | {α : Type u_4} → {inst : TopologicalSpace α} → TopologicalSpace.CompactOpens α → ℕ | false |
Real.HolderTriple.inv_sub_inv_eq_inv | Mathlib.Data.Real.ConjExponents | ∀ {p q r : ℝ}, p.HolderTriple q r → r⁻¹ - q⁻¹ = p⁻¹ | true |
Std.Time.Minute.instDecidableLtOrdinal._aux_1 | Std.Time.Time.Unit.Minute | {x y : Std.Time.Minute.Ordinal} → Decidable (x < y) | false |
LatticeHom.withBotWithTop'._proof_1 | Mathlib.Order.Hom.WithTopBot | ∀ {α : Type u_2} {β : Type u_1} [inst : Lattice α] [inst_1 : Lattice β] [inst_2 : BoundedOrder β] (f : LatticeHom α β),
f.withTop'.withBot'.toInfHom.toFun ⊥ = f.withTop'.withBot'.toInfHom.toFun ⊥ | false |
Array.start_mkSlice_roc | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {lo hi : ℕ},
(Std.Roc.Sliceable.mkSlice xs lo<...=hi).start = min (lo + 1) (min (hi + 1) xs.size) | true |
Set.union_eq_compl_compl_inter_compl | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} (s t : Set α), s ∪ t = (sᶜ ∩ tᶜ)ᶜ | true |
CategoryTheory.ComposableArrows.Precomp.obj.match_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | {n : ℕ} →
(motive : Fin (n + 1 + 1) → Sort u_1) →
(x : Fin (n + 1 + 1)) →
((isLt : 0 < n + 1 + 1) → motive ⟨0, isLt⟩) →
((i : ℕ) → (hi : i + 1 < n + 1 + 1) → motive ⟨i.succ, hi⟩) → motive x | false |
NonUnitalStarAlgHom.map_star' | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : Monoid R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : DistribMulAction R A] [inst_3 : Star A] [inst_4 : NonUnitalNonAssocSemiring B]
[inst_5 : DistribMulAction R B] [inst_6 : Star B] (self : A →⋆ₙₐ[R] B) (a : A),
self.toFun (star a) = star (self.toFun a) | true |
Finset.sdiff_empty | Mathlib.Data.Finset.SDiff | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α}, s \ ∅ = s | true |
Quaternion.instGroupWithZero._proof_4 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : Field R] (n : ℕ) (a : Quaternion R),
zpowRec npowRec (Int.negSucc n) a = (zpowRec npowRec (↑n.succ) a)⁻¹ | false |
MulEquiv.subgroupCongr.congr_simp | Mathlib.GroupTheory.GroupAction.Basic | ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G} (h : H = K), MulEquiv.subgroupCongr h = MulEquiv.subgroupCongr h | true |
Lean.Meta.Tactic.Cbv.CbvEvalState.mk.noConfusion | Lean.Meta.Tactic.Cbv.CbvEvalExt | {P : Sort u} →
{lemmas : Lean.NameMap Lean.Meta.Sym.Simp.Theorems} →
{entries : Lean.NameMap (Array Lean.Meta.Tactic.Cbv.CbvEvalEntry)} →
{lemmas' : Lean.NameMap Lean.Meta.Sym.Simp.Theorems} →
{entries' : Lean.NameMap (Array Lean.Meta.Tactic.Cbv.CbvEvalEntry)} →
{ lemmas := lemmas, entries... | false |
Lean.Meta.Grind.Arith.Linear.EqCnstr._sizeOf_5 | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Lean.Meta.Grind.Arith.Linear.DiseqCnstr → ℕ | false |
WeierstrassCurve.variableChange_b₈ | Mathlib.AlgebraicGeometry.EllipticCurve.VariableChange | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) (C : WeierstrassCurve.VariableChange R),
(C • W).b₈ = ↑C.u⁻¹ ^ 8 * (W.b₈ + 3 * C.r * W.b₆ + 3 * C.r ^ 2 * W.b₄ + C.r ^ 3 * W.b₂ + 3 * C.r ^ 4) | true |
Turing.TM2.stmts.eq_1 | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} (M : Λ → Turing.TM2.Stmt Γ Λ σ) (S : Finset Λ),
Turing.TM2.stmts M S = Finset.insertNone (S.biUnion fun q => Turing.TM2.stmts₁ (M q)) | true |
Unitary.smul_mem | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_1} {A : Type u_2} [inst : Monoid R] [inst_1 : Monoid A] [inst_2 : MulAction R A] [SMulCommClass R A A]
[IsScalarTower R A A] [inst_5 : StarMul R] [inst_6 : StarMul A] [StarModule R A] (r : ↥(unitary R)) {a : A},
a ∈ unitary A → r • a ∈ unitary A | true |
Lat.ext_iff | Mathlib.Order.Category.Lat | ∀ {X Y : Lat} {f g : X ⟶ Y},
f = g ↔ ∀ (x : ↑X), (CategoryTheory.ConcreteCategory.hom f) x = (CategoryTheory.ConcreteCategory.hom g) x | true |
_private.Mathlib.RingTheory.Ideal.IsPrincipal.0.Ideal.associatesEquivIsPrincipal._simp_3 | Mathlib.RingTheory.Ideal.IsPrincipal | ∀ {α : Sort u_1} {r : Setoid α} {x y : α}, (⟦x⟧ = ⟦y⟧) = r x y | false |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsCycle.count_support._proof_1_15 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} {G : SimpleGraph V} {v : V} [inst : DecidableEq V] {c : G.Walk v v},
List.count v c.support.tail = 1 → List.findIdxNth (fun x => decide (x = v)) c.support.tail 0 < c.support.tail.length | false |
Std.DHashMap.Internal.Raw₀.getKey!_eq_of_contains | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [LawfulBEq α]
[inst_3 : Inhabited α], (↑m).WF → ∀ {k : α}, m.contains k = true → m.getKey! k = k | true |
SequentiallyComplete.setSeqAux._proof_1 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u_1} [uniformSpace : UniformSpace α] {f : Filter α},
Cauchy f → ∀ {U : ℕ → SetRel α α}, (∀ (n : ℕ), U n ∈ uniformity α) → ∀ (n : ℕ), ∃ t ∈ f, t ×ˢ t ⊆ U n | false |
_private.Mathlib.AlgebraicGeometry.Sites.SheafQuasiCompact.0.AlgebraicGeometry.isSheaf_propQCTopology_iff._proof_1_1 | Mathlib.AlgebraicGeometry.Sites.SheafQuasiCompact | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [P.IsStableUnderBaseChange] {A : Type u_3}
[inst : CategoryTheory.Category.{u_2, u_3} A] [P.IsMultiplicative]
(F : CategoryTheory.Functor AlgebraicGeometry.Schemeᵒᵖ A) [AlgebraicGeometry.IsZariskiLocalAtSource P],
CategoryTheory.Presheaf.IsSheaf
... | false |
_private.Mathlib.Data.Fin.Basic.0.Fin.coe_int_add_eq_ite._proof_1_2 | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} (u v : Fin n), 0 ≤ ↑(↑u + ↑v) | false |
_private.Mathlib.Topology.IndicatorConstPointwise.0.tendsto_indicator_const_apply_iff_eventually'._simp_1_2 | Mathlib.Topology.IndicatorConstPointwise | ∀ {α : Type u_1} {a : α} {s : Set α}, (s ∈ pure a) = (a ∈ s) | false |
QuadraticForm.comp_tensorRId_eq | Mathlib.LinearAlgebra.QuadraticForm.TensorProduct.Isometries | ∀ {R : Type uR} {M₁ : Type uM₁} [inst : CommRing R] [inst_1 : AddCommGroup M₁] [inst_2 : Module R M₁]
[inst_3 : Invertible 2] (Q₁ : QuadraticForm R M₁),
QuadraticMap.comp Q₁ ↑(TensorProduct.rid R M₁) = Q₁.tmul QuadraticMap.sq | true |
_private.Lean.Meta.Tactic.Grind.ProveEq.0.Lean.Meta.Grind.AbstractM.Context | Lean.Meta.Tactic.Grind.ProveEq | Type | true |
Std.HashMap.Raw.keysArray | Std.Data.HashMap.Raw | {α : Type u} → {β : Type v} → Std.HashMap.Raw α β → Array α | true |
Mathlib.Meta.Positivity.evalProjMulHeight | Mathlib.NumberTheory.Height.Projectivization | Mathlib.Meta.Positivity.PositivityExt | true |
_private.Mathlib.Data.Int.CardIntervalMod.0.Int.Ico_filter_modEq_eq._simp_1_3 | Mathlib.Data.Int.CardIntervalMod | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Ico a b) = (a ≤ x ∧ x < b) | false |
Set.Icc.coe_eq_zero | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R] {x : ↑(Set.Icc 0 1)},
↑x = 0 ↔ x = 0 | true |
Set.embeddingOfSubset._proof_5 | Mathlib.Logic.Embedding.Set | ∀ {α : Type u_1} (s t : Set α) (h : s ⊆ t) (x : α) (hx : x ∈ s) (y : α) (hy : y ∈ s),
(fun x => ⟨↑x, ⋯⟩) ⟨x, hx⟩ = (fun x => ⟨↑x, ⋯⟩) ⟨y, hy⟩ → ⟨x, hx⟩ = ⟨y, hy⟩ | false |
List.dProdIndex_eq_map_sum._f | Mathlib.Algebra.GradedMonoid | ∀ {ι : Type u_1} {α : Type u_2} [inst : AddMonoid ι] (fι : α → ι) (l : List α) (f : List.below l),
l.dProdIndex fι = (List.map fι l).sum | false |
CategoryTheory.Subgroupoid.disconnect_objs | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C), S.disconnect.objs = S.objs | true |
_private.Mathlib.Analysis.Complex.Conformal.0.isConformalMap_complex_linear._simp_1_3 | Mathlib.Analysis.Complex.Conformal | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | false |
Std.DTreeMap.Internal.Impl.Const.get_eq_get! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
[inst : Inhabited β],
t.WF →
∀ {a : α} {h : Std.DTreeMap.Internal.Impl.contains a t = true},
Std.DTreeMap.Internal.Impl.Const.get t a h = Std.DTreeMap.Internal.Impl.Const.get! t a | true |
Function.RightInverse.surjective | Init.Data.Function | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α}, Function.RightInverse g f → Function.Surjective f | true |
Std.DHashMap.Internal.Raw₀.get!_diff_of_contains_eq_false_right | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β}
[inst_2 : LawfulBEq α],
(↑m₁).WF → (↑m₂).WF → ∀ {k : α} [inst_3 : Inhabited (β k)], m₂.contains k = false → (m₁.diff m₂).get! k = m₁.get! k | true |
Cubic | Mathlib.Algebra.CubicDiscriminant | Type u_1 → Type u_1 | true |
Finset.intervalGapsWithin_snd_of_lt | Mathlib.Order.Interval.Finset.Gaps | ∀ {α : Type u_1} [inst : LinearOrder α] (F : Finset (α × α)) {k : ℕ} (h : F.card = k) (a b : α) (j : ℕ) (hj : j < k),
(F.intervalGapsWithin h a b ↑j).2 = ((F.orderEmbOfFin h) ⟨j, hj⟩).1 | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_301 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α),
2 ≤ List.count w_1 [g a, g (g a)] →
List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] [].length) <
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.0._regBuiltin.Char.reduceDefault.declare_123._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.1879646975._hygCtx._hyg.15 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | IO Unit | false |
Std.ExtTreeMap.getElem!_modify | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k k' : α}
[hi : Inhabited β] {f : β → β},
(t.modify k f)[k']! = if cmp k k' = Ordering.eq then (Option.map f t[k]?).get! else t[k']! | true |
CategoryTheory.Limits.combineCocones._proof_7 | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] {K : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} K]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C))
(c : (k : K) → CategoryTheory.Limits.ColimitCocone (F.flip.obj k)... | false |
Lean.Meta.Sym.Config.mk.injEq | Lean.Meta.Sym.SymM | ∀ (verbose verbose_1 : Bool), ({ verbose := verbose } = { verbose := verbose_1 }) = (verbose = verbose_1) | true |
RingCon.quotientKerEquivOfSurjective._proof_2 | Mathlib.RingTheory.Congruence.Hom | ∀ {M : Type u_1} {P : Type u_2} [inst : NonAssocSemiring M] [inst_1 : NonAssocSemiring P] (f : M →+* P)
(hf : Function.Surjective ⇑f), Function.RightInverse (Exists.choose ⋯) ⇑f | false |
CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.unitIso._proof_2 | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] [inst_2 : CategoryTheory.MonoidalCategory D]
(A : CategoryTheory.Mon (CategoryTheory.Functor C D)) ⦃X Y : C⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor... | false |
Multiset.sum_eq_zero | Mathlib.Algebra.BigOperators.Group.Multiset.Basic | ∀ {M : Type u_5} [inst : AddCommMonoid M] {s : Multiset M}, (∀ x ∈ s, x = 0) → s.sum = 0 | true |
IsLocalizedModule.isInteger_smul | Mathlib.Algebra.Module.LocalizedModule.Int | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {M' : Type u_3}
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (f : M →ₗ[R] M') {a : R} {x : M'},
IsLocalizedModule.IsInteger f x → IsLocalizedModule.IsInteger f (a • x) | true |
_private.Mathlib.LinearAlgebra.Matrix.ToLin.0.range_vecMulLinear._simp_1_2 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {α : Type u} [inst : Semiring α], ⊤ = Ideal.span {1} | false |
PartitionOfUnity.mem_fintsupport_iff | Mathlib.Topology.PartitionOfUnity | ∀ {ι : Type u} {X : Type v} [inst : TopologicalSpace X] {s : Set X} (ρ : PartitionOfUnity ι X s) (x₀ : X) (i : ι),
i ∈ ρ.fintsupport x₀ ↔ x₀ ∈ tsupport ⇑(ρ i) | true |
Lean.Server.GoToKind.recOn | Lean.Server.GoTo | {motive : Lean.Server.GoToKind → Sort u} →
(t : Lean.Server.GoToKind) →
motive Lean.Server.GoToKind.declaration →
motive Lean.Server.GoToKind.definition → motive Lean.Server.GoToKind.type → motive t | false |
Std.ExtDTreeMap.getKey!_modify | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] [inst_2 : Inhabited α] {k k' : α} {f : β k → β k},
(t.modify k f).getKey! k' = if cmp k k' = Ordering.eq then if k ∈ t then k else default else t.getKey! k' | true |
PowerSeries.C_injective | Mathlib.RingTheory.PowerSeries.Basic | ∀ {R : Type u_1} [inst : Semiring R], Function.Injective ⇑PowerSeries.C | true |
Lean.Parser.Term.stateRefT._regBuiltin.Lean.Parser.Term.stateRefT.formatter_17 | Lean.Parser.Term | IO Unit | false |
Lean.Parser.Command.initialize._regBuiltin.Lean.Parser.Command.initialize.parenthesizer_19 | Lean.Parser.Command | IO Unit | false |
CategoryTheory.Limits.WidePushoutShape.wideSpan._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type u_1} {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (B : C) (objs : J → C)
(arrows : (j : J) → B ⟶ objs j) (X : CategoryTheory.Limits.WidePushoutShape J),
CategoryTheory.Limits.WidePushoutShape.Hom.casesOn (motive := fun a a_1 x =>
X = a → X = a_1 → CategoryTheory.CategoryStruct.id X... | false |
Function.Injective.ne_iff' | Init.Data.Function | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β}, Function.Injective f → ∀ {x y : α} {z : β}, f y = z → (f x ≠ z ↔ x ≠ y) | true |
Lean.Meta.declFromEqLikeName | Lean.Meta.Eqns | Lean.Environment → Lean.Name → Option (Lean.Name × String) | true |
instCommGroupClassGroup._proof_10 | Mathlib.RingTheory.ClassGroup | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsDomain R],
autoParam (∀ (x : ClassGroup R), instCommGroupClassGroup._aux_8 R 0 x = 1) Monoid.npow_zero._autoParam | false |
posPart_negPart_inj | Mathlib.Algebra.Order.Group.PosPart | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddGroup α] {a b : α} [AddLeftMono α], a⁺ = b⁺ ∧ a⁻ = b⁻ ↔ a = b | true |
isClosed_eq | Mathlib.Topology.Separation.Hausdorff | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [T2Space X] {f g : Y → X},
Continuous f → Continuous g → IsClosed {y | f y = g y} | true |
List.foldr_unattach | Init.Data.List.Attach | ∀ {α : Type u_1} {β : Type u_2} {P : α → Prop} {xs : List (Subtype P)} {f : α → β → β} {x : β},
List.foldr f x xs.unattach =
List.foldr
(fun x s =>
match x with
| ⟨x, h⟩ => binderNameHint x f (binderNameHint s (f x) (binderNameHint h () (f (wfParam x) s))))
x xs | true |
_private.Mathlib.Analysis.Meromorphic.Divisor.0.MeromorphicOn.divisor._simp_7 | Mathlib.Analysis.Meromorphic.Divisor | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.