name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Lsp.DiagnosticRelatedInformation.mk.noConfusion | Lean.Data.Lsp.Diagnostics | {P : Sort u} →
{location : Lean.Lsp.Location} →
{message : String} →
{location' : Lean.Lsp.Location} →
{message' : String} →
{ location := location, message := message } = { location := location', message := message' } →
(location = location' → message = message' → P) → P | false |
instInhabitedBool.default | Init.Prelude | Bool | true |
_private.Mathlib.LinearAlgebra.Matrix.Notation.0.Matrix.delabMatrixNotation._sparseCasesOn_1 | Mathlib.LinearAlgebra.Matrix.Notation | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
WeierstrassCurve.integralModel | Mathlib.AlgebraicGeometry.EllipticCurve.Reduction | (R : Type u_1) →
[inst : CommRing R] →
{K : Type u_2} →
[inst_1 : Field K] →
[inst_2 : Algebra R K] → (W : WeierstrassCurve K) → [hW : WeierstrassCurve.IsIntegral R W] → WeierstrassCurve R | true |
_private.Mathlib.MeasureTheory.SetSemiring.0.MeasureTheory.IsSetSemiring.empty_notMem_disjointOfDiffUnion._simp_1_4 | Mathlib.MeasureTheory.SetSemiring | (¬True) = False | false |
_private.Std.Time.Date.Unit.Weekday.0.Std.Time.Weekday.toOrdinal.eq_5 | Std.Time.Date.Unit.Weekday | Std.Time.Weekday.friday.toOrdinal = 5 | true |
Int.fib_dvd | Mathlib.Data.Int.Fib.Basic | ∀ (m n : ℤ), m ∣ n → Int.fib m ∣ Int.fib n | true |
ZMod.inv | Mathlib.Data.ZMod.Basic | (n : ℕ) → ZMod n → ZMod n | true |
Aesop.instBEqPhaseName.beq | Aesop.Rule.Name | Aesop.PhaseName → Aesop.PhaseName → Bool | true |
AbsConvexOpenSets.coe_isOpen | Mathlib.Analysis.LocallyConvex.AbsConvexOpen | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : TopologicalSpace E] [inst_1 : AddCommMonoid E] [inst_2 : SeminormedRing 𝕜]
[inst_3 : SMul 𝕜 E] [inst_4 : PartialOrder 𝕜] (s : AbsConvexOpenSets 𝕜 E), IsOpen ↑s | true |
_private.Mathlib.Order.Interval.Set.Disjoint.0.Set.Ioo_disjoint_Ioo._simp_1_2 | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type u_1} [inst : Preorder α] {a b : α} [DenselyOrdered α], (Set.Ioo a b = ∅) = ¬a < b | false |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.IsPath.snd_of_toSubgraph_adj._proof_1_7 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} {u v v' : V} {p : G.Walk u v} (i : ℕ),
(p.getVert i = u ∧ p.getVert (i + 1) = v' ∨ p.getVert i = v' ∧ p.getVert (i + 1) = u) ∧ i < p.length →
i + 1 ≤ p.length | false |
_private.Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots.0.IsPrimitiveRoot.card_nthRoots._simp_1_1 | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {α : Type u_1} {s : Multiset α}, (s.card = 0) = (s = 0) | false |
Lean.Meta.Grind.Arith.Cutsat.SymbolicBound.rec | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | {motive : Lean.Meta.Grind.Arith.Cutsat.SymbolicBound → Sort u} →
((val : Lean.Expr) → (ival? : Option ℤ) → motive { val := val, ival? := ival? }) →
(t : Lean.Meta.Grind.Arith.Cutsat.SymbolicBound) → motive t | false |
Std.TreeSet.isNone_max?_eq_isEmpty | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp], t.max?.isNone = t.isEmpty | true |
Std.TreeMap.Raw.size_insert | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {v : β}, (t.insert k v).size = if t.contains k = true then t.size else t.size + 1 | true |
Lean.reservedMacroScope | Init.Prelude | ℕ | true |
cfcₙ_comp_smul._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | false |
Std.TreeMap.getKey!_union | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α] {k : α}, (t₁ ∪ t₂).getKey! k = t₂.getKeyD k (t₁.getKey! k) | true |
LinearMap.ker_eq_top._simp_1 | Mathlib.Algebra.Module.Submodule.Ker | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_7} [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₂}
{f : M →ₛₗ[τ₁₂] M₂}, (f.ker = ⊤) = (f = 0) | false |
RegularWreathProduct.mk.injEq | Mathlib.GroupTheory.RegularWreathProduct | ∀ {D : Type u_1} {Q : Type u_2} (left : Q → D) (right : Q) (left_1 : Q → D) (right_1 : Q),
({ left := left, right := right } = { left := left_1, right := right_1 }) = (left = left_1 ∧ right = right_1) | true |
Field.Emb.Cardinal.leastExt.eq_1 | Mathlib.FieldTheory.CardinalEmb | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
[rank_inf : Fact (Cardinal.aleph0 ≤ Module.rank F E)] [inst_3 : Algebra.IsAlgebraic F E],
Field.Emb.Cardinal.leastExt F E =
⋯.fix fun i ih =>
let s := Set.range fun j => (Field.Emb.Cardinal.wellOrderedBasis F E) (ih ↑j ... | true |
ContinuousAlgHom.coe_mk' | Mathlib.Topology.Algebra.Algebra | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : TopologicalSpace A]
{B : Type u_3} [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(f : A →ₐ[R] B) (h : Continuous (↑↑f.toRingHom).toFun), ⇑{ toAlgHom := f, cont := h } = ⇑f | true |
ProbabilityTheory.variance_id_gaussianReal | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal}, ProbabilityTheory.variance id (ProbabilityTheory.gaussianReal μ v) = ↑v | true |
Turing.PartrecToTM2.trStmts₁_supports' | Mathlib.Computability.TuringMachine.ToPartrec | ∀ {S : Finset Turing.PartrecToTM2.Λ'} {q : Turing.PartrecToTM2.Λ'} {K : Finset Turing.PartrecToTM2.Λ'},
Turing.PartrecToTM2.Λ'.Supports S q →
Turing.PartrecToTM2.trStmts₁ q ∪ K ⊆ S →
(K ⊆ S → Turing.PartrecToTM2.Supports K S) → Turing.PartrecToTM2.Supports (Turing.PartrecToTM2.trStmts₁ q ∪ K) S | true |
Std.Time.Year.instSubOffset | Std.Time.Date.Unit.Year | Sub Std.Time.Year.Offset | true |
Lean.Elab.MonadAutoImplicits.recOn | Lean.Elab.InfoTree.Types | {m : Type → Type} →
{motive : Lean.Elab.MonadAutoImplicits m → Sort u} →
(t : Lean.Elab.MonadAutoImplicits m) →
((getAutoImplicits : m (Array Lean.Expr)) → motive { getAutoImplicits := getAutoImplicits }) → motive t | false |
Associated.mul_mul | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoid M] {a₁ a₂ b₁ b₂ : M},
Associated a₁ b₁ → Associated a₂ b₂ → Associated (a₁ * a₂) (b₁ * b₂) | true |
Submodule.generators_card | Mathlib.Algebra.Module.SpanRank | ∀ {R : Type u_1} {M : Type u} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (p : Submodule R M),
Cardinal.mk ↑p.generators = p.spanRank | true |
Ordinal.cof_eq_zero._simp_1 | Mathlib.SetTheory.Cardinal.Cofinality | ∀ {o : Ordinal.{u_1}}, (o.cof = 0) = (o = 0) | false |
Polynomial.Splits.of_degree_eq_two | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : Field R] {f : Polynomial R} {x : R}, f.degree = 2 → Polynomial.eval x f = 0 → f.Splits | true |
Height.AdmissibleAbsValues.mk._flat_ctor | Mathlib.NumberTheory.Height.Basic | {K : Type u_1} →
[inst : Field K] →
(archAbsVal : Multiset (AbsoluteValue K ℝ)) →
(nonarchAbsVal : Set (AbsoluteValue K ℝ)) →
(∀ v ∈ nonarchAbsVal, IsNonarchimedean ⇑v) →
(∀ {x : K}, x ≠ 0 → Function.HasFiniteMulSupport fun v => ↑v x) →
(∀ {x : K}, x ≠ 0 → (Multiset.map (fun x_... | false |
Plausible.GenError.ctorIdx | Plausible.Gen | Plausible.GenError → ℕ | false |
Fact.mk | Mathlib.Logic.Basic | ∀ {p : Prop}, p → Fact p | true |
Set.chainHeight_coe_univ | Mathlib.Order.Height | ∀ {α : Type u_1} (s : Set α) (r : α → α → Prop), (Set.univ.chainHeight fun x1 x2 => r ↑x1 ↑x2) = s.chainHeight r | true |
Valuation.restrict_le_iff_le_embedding | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀)
{x : R} {g : MonoidWithZeroHom.ValueGroup₀ v}, v.restrict x ≤ g ↔ v x ≤ MonoidWithZeroHom.ValueGroup₀.embedding g | true |
Lean.Lsp.FileChangeType.recOn | Lean.Data.Lsp.Workspace | {motive : Lean.Lsp.FileChangeType → Sort u} →
(t : Lean.Lsp.FileChangeType) →
motive Lean.Lsp.FileChangeType.Created →
motive Lean.Lsp.FileChangeType.Changed → motive Lean.Lsp.FileChangeType.Deleted → motive t | false |
BitVec.getLsbD_succ_last | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x : BitVec (w + 1)), x.getLsbD w = decide (2 ^ w ≤ x.toNat) | true |
_private.Mathlib.ModelTheory.Encoding.0.FirstOrder.Language.BoundedFormula.listEncode.match_1.eq_2 | Mathlib.ModelTheory.Encoding | ∀ {L : FirstOrder.Language} {α : Type u_3} (motive : (x : ℕ) → L.BoundedFormula α x → Sort u_4) (x : ℕ)
(t₁ t₂ : L.Term (α ⊕ Fin x)) (h_1 : (n : ℕ) → motive n FirstOrder.Language.BoundedFormula.falsum)
(h_2 : (x : ℕ) → (t₁ t₂ : L.Term (α ⊕ Fin x)) → motive x (FirstOrder.Language.BoundedFormula.equal t₁ t₂))
(h_3 ... | true |
CategoryTheory.Pseudofunctor.DescentData'.ofDescentData._proof_13 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} {ι : Type u_5} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} (sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j))
(D : F.DescentData f) (i : ι),
... | false |
Composition.reverse_eq_ones | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} {c : Composition n}, c.reverse = Composition.ones n ↔ c = Composition.ones n | true |
Lean.Syntax.instForInTopDownOfMonad.match_1 | Lean.Syntax | (motive : Lean.Syntax → Sort u_1) →
(stx : Lean.Syntax) →
((info : Lean.SourceInfo) →
(k : Lean.SyntaxNodeKind) → (args : Array Lean.Syntax) → motive (Lean.Syntax.node info k args)) →
((x : Lean.Syntax) → motive x) → motive stx | false |
Array.forIn'_eq_forIn' | Init.Data.Array.Basic | ∀ {α : Type u} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Monad m], Array.forIn' = forIn' | true |
HahnSeries.embDomainRingHom._proof_4 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} {R : Type u_2} [inst : AddCommMonoid Γ] [inst_1 : PartialOrder Γ] {Γ' : Type u_3}
[inst_2 : AddCommMonoid Γ'] [inst_3 : PartialOrder Γ'] [inst_4 : NonAssocSemiring R] (f : Γ →+ Γ')
(hfi : Function.Injective ⇑f) (hf : ∀ (g g' : Γ), f g ≤ f g' ↔ g ≤ g') (x y : HahnSeries Γ R),
HahnSeries.embDomain ... | false |
CategoryTheory.rightAdjointMate_comp | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y Z : C}
[inst_2 : CategoryTheory.HasRightDual X] [inst_3 : CategoryTheory.HasRightDual Y] {f : X ⟶ Y} {g : Xᘁ ⟶ Z},
CategoryTheory.CategoryStruct.comp (fᘁ) g =
CategoryTheory.CategoryStruct.comp (Categor... | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxsOf_lt._proof_1_10 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ} {xs : List α} {x : α} {s : ℕ} [inst : BEq α],
i < (List.idxsOf x xs s).length → 0 < (List.findIdxs (fun x_1 => x_1 == x) xs).length | false |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithTerminal.opEquiv.match_15.eq_2 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ (C : Type u_1) (motive : CategoryTheory.WithInitial Cᵒᵖ → Sort u_2)
(h_1 : (x : Cᵒᵖ) → motive (CategoryTheory.WithInitial.of x)) (h_2 : Unit → motive CategoryTheory.WithInitial.star),
(match CategoryTheory.WithInitial.star with
| CategoryTheory.WithInitial.of x => h_1 x
| CategoryTheory.WithInitial.star =... | true |
Std.ExtDTreeMap.getKey?_filterMap | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} {γ : α → Type w}
[inst : Std.TransCmp cmp] [inst_1 : Std.LawfulEqCmp cmp] {f : (a : α) → β a → Option (γ a)} {k : α},
(Std.ExtDTreeMap.filterMap f t).getKey? k = (t.getKey? k).pfilter fun x h' => (f x (t.get x ⋯)).isSome | true |
withTheReader.eq_1 | Std.Do.Triple.SpecLemmas | ∀ (ρ : Type u) {m : Type u → Type v} [inst : MonadWithReaderOf ρ m] {α : Type u} (f : ρ → ρ) (x : m α),
withTheReader ρ f x = MonadWithReaderOf.withReader f x | true |
_private.Mathlib.Algebra.Exact.0.Function.Exact.inr_fst._simp_1_1 | Mathlib.Algebra.Exact | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | false |
CategoryTheory.Functor.RightExtension.isUniversalEquivOfIso₂._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {H : Type u_3} {D : Type u_5} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_2, u_3} H] [inst_2 : CategoryTheory.Category.{u_6, u_5} D]
{L : CategoryTheory.Functor C D} {F₁ F₂ : CategoryTheory.Functor C H} (α₁ : L.RightExtension F₁)
(α₂ : L.RightExtension F₂) (... | false |
_private.Mathlib.Order.Directed.0.Directed.mono.match_1_1 | Mathlib.Order.Directed | ∀ {α : Type u_2} {r : α → α → Prop} {ι : Sort u_1} {f : ι → α} (a b : ι)
(motive : (∃ z, r (f a) (f z) ∧ r (f b) (f z)) → Prop) (x : ∃ z, r (f a) (f z) ∧ r (f b) (f z)),
(∀ (c : ι) (h₁ : r (f a) (f c)) (h₂ : r (f b) (f c)), motive ⋯) → motive x | false |
_private.Lean.Meta.Tactic.Grind.Main.0.Lean.Meta.Grind.resolveDelayedMVarAssignments | Lean.Meta.Tactic.Grind.Main | Lean.Expr → Lean.MetaM Lean.Expr | true |
ContinuousLinearMap.adjointAux._proof_10 | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E],
SMulCommClass 𝕜 𝕜 (StrongDual 𝕜 E) | false |
Function.bUnion_ptsOfPeriod | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {α : Type u_1} (f : α → α), ⋃ n, ⋃ (_ : n > 0), Function.ptsOfPeriod f n = Function.periodicPts f | true |
Lean.Meta.ExtractLetsConfig._sizeOf_inst | Init.MetaTypes | SizeOf Lean.Meta.ExtractLetsConfig | false |
ProbabilityTheory.cgf_undef | Mathlib.Probability.Moments.Basic | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω} {t : ℝ},
¬MeasureTheory.Integrable (fun ω => Real.exp (t * X ω)) μ → ProbabilityTheory.cgf X μ t = 0 | true |
SimpleGraph.IsEdgeReachable.of_subsingleton | Mathlib.Combinatorics.SimpleGraph.Connectivity.EdgeConnectivity | ∀ {V : Type u_1} {G : SimpleGraph V} {k : ℕ} {u v : V} [Subsingleton V], G.IsEdgeReachable k u v | true |
SemidirectProduct.equivProd_symm_apply_left | Mathlib.GroupTheory.SemidirectProduct | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {φ : G →* MulAut N} (x : N × G),
(SemidirectProduct.equivProd.symm x).left = x.1 | true |
Turing.TM2to1.trNormal.eq_3 | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} (k : K) (a : σ → Option (Γ k) → σ)
(q : Turing.TM2.Stmt Γ Λ σ),
Turing.TM2to1.trNormal (Turing.TM2.Stmt.pop k a q) =
Turing.TM1.Stmt.goto fun x x_1 => Turing.TM2to1.Λ'.go k (Turing.TM2to1.StAct.pop a) q | true |
Aesop.Check.mk | Aesop.Check | Lean.Option Bool → Aesop.Check | true |
herglotzRieszKernel_def | Mathlib.Analysis.Complex.Poisson | ∀ (c w z : ℂ), herglotzRieszKernel c w z = (z - c + (w - c)) / (z - c - (w - c)) | true |
CategoryTheory.ChosenPullbacksAlong.pullbackCone_snd | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Y Z X : C} (f : Y ⟶ X) (g : Z ⟶ X)
[inst_1 : CategoryTheory.ChosenPullbacksAlong g],
(CategoryTheory.ChosenPullbacksAlong.pullbackCone f g).snd = CategoryTheory.ChosenPullbacksAlong.snd f g | true |
UInt32.toUSize_lt | Init.Data.UInt.Lemmas | ∀ {a b : UInt32}, a.toUSize < b.toUSize ↔ a < b | true |
AddSubgroup.even._proof_1 | Mathlib.Algebra.Group.Subgroup.Even | ∀ (G : Type u_1) [inst : AddCommGroup G] {x : G}, Even x → Even (-x) | false |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NNReal.0.NNReal.rpow_pos._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : PartialOrder α] [ZeroLEOneClass α] [NeZero 1],
(0 < 1) = True | false |
IntermediateField.restrictScalars_toSubfield | Mathlib.FieldTheory.IntermediateField.Basic | ∀ (K : Type u_1) {L : Type u_2} {L' : Type u_3} [inst : Field K] [inst_1 : Field L] [inst_2 : Field L']
[inst_3 : Algebra K L] [inst_4 : Algebra K L'] [inst_5 : Algebra L' L] [inst_6 : IsScalarTower K L' L]
{E : IntermediateField L' L}, (IntermediateField.restrictScalars K E).toSubfield = E.toSubfield | true |
Fin.finsetImage_natAdd_Ioc | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (m : ℕ) (i j : Fin n),
Finset.image (Fin.natAdd m) (Finset.Ioc i j) = Finset.Ioc (Fin.natAdd m i) (Fin.natAdd m j) | true |
_private.Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis.0.AlgebraicIndependent.matroid_closure_eq._simp_1_8 | Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis | ∀ {R : Type u_1} {A : Type w} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : FaithfulSMul R A] [inst_4 : IsDomain A] {s t : Set A},
(AlgebraicIndependent.matroid R A).IsBasis s t =
(AlgebraicIndepOn R id s ∧ s ⊆ t ∧ ∀ a ∈ t, IsAlgebraic (↥(Algebra.adjoin R s)) a) | false |
Perfection.teichmullerAux.congr_simp | Mathlib.RingTheory.Teichmuller | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {R : Type u_1} [inst_1 : CommRing R] {I : Ideal R} [inst_2 : CharP (R ⧸ I) p]
(x x_1 : Perfection (R ⧸ I) p), x = x_1 → ∀ (a a_1 : ℕ), a = a_1 → x.teichmullerAux a = x_1.teichmullerAux a_1 | true |
Lean.Meta.coerceCollectingNames? | Lean.Meta.Coe | Lean.Expr → Lean.Expr → Lean.MetaM (Lean.LOption (Lean.Expr × List Lean.Name)) | true |
_private.Lean.Elab.MacroRules.0.Lean.Elab.Command.elabMacroRulesAux._sparseCasesOn_3 | Lean.Elab.MacroRules | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
AlgebraicIndependent.mvPolynomialOptionEquivPolynomialAdjoin.congr_simp | Mathlib.RingTheory.AlgebraicIndependent.Basic | ∀ {ι : Type u} {R : Type u_2} {A : Type v} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
(hx : AlgebraicIndependent R x),
hx.mvPolynomialOptionEquivPolynomialAdjoin = hx.mvPolynomialOptionEquivPolynomialAdjoin | true |
BoundedContinuousFunction.instNSMul._proof_2 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u_1} {R : Type u_2} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace R] [inst_2 : AddMonoid R]
[ContinuousAdd R] (f : BoundedContinuousFunction α R) (n : ℕ), Continuous fun b => n • f b | false |
_private.Mathlib.GroupTheory.FiniteAbelian.Duality.0.CommGroup.mem_subgroupOrderIsoSubgroupMonoidHom_symm_iff._simp_1_3 | Mathlib.GroupTheory.FiniteAbelian.Duality | ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] {f : G ≃* N} {K : Subgroup G} {x : N},
(x ∈ Subgroup.map f.toMonoidHom K) = (f.symm x ∈ K) | false |
MeasureTheory.OuterMeasure.exists_measurable_superset_forall_eq_trim | Mathlib.MeasureTheory.OuterMeasure.Induced | ∀ {α : Type u_1} [inst : MeasurableSpace α] {ι : Sort u_2} [Countable ι] (μ : ι → MeasureTheory.OuterMeasure α)
(s : Set α), ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ∀ (i : ι), (μ i) t = (μ i).trim s | true |
UpperSet.commSemigroup.eq_1 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α],
UpperSet.commSemigroup = Function.Injective.commSemigroup SetLike.coe ⋯ ⋯ | true |
Set.pow_mem_pow | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Monoid α] {s : Set α} {a : α} {n : ℕ}, a ∈ s → a ^ n ∈ s ^ n | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeftConst._proof_7 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft | ∀ {w : ℕ}, ∀ curr ≤ w, ¬curr < w → ¬curr = w → False | false |
LieAlgebra.SemiDirectSum.mk._flat_ctor | Mathlib.Algebra.Lie.SemiDirect | {R : Type u_1} →
[inst : CommRing R] →
{K : Type u_2} →
[inst_1 : LieRing K] →
[inst_2 : LieAlgebra R K] →
{L : Type u_3} →
[inst_3 : LieRing L] → [inst_4 : LieAlgebra R L] → {x : L →ₗ⁅R⁆ LieDerivation R K K} → K → L → K ⋊⁅x⁆ L | false |
String.Internal.next | Init.Data.String.Bootstrap | String → String.Pos.Raw → String.Pos.Raw | true |
CategoryTheory.TwoSquare.guitartExact_id' | Mathlib.CategoryTheory.GuitartExact.Opposite | ∀ {C₁ : Type u₁} {C₂ : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] (F : CategoryTheory.Functor C₁ C₂),
(CategoryTheory.TwoSquare.mk F (CategoryTheory.Functor.id C₁) (CategoryTheory.Functor.id C₂) F
(CategoryTheory.CategoryStruct.id F)).GuitartExact | true |
CategoryTheory.regularTopology.equalizerCondition_iff_of_equivalence | Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves | ∀ {C : Type u_1} {D : Type u_2} {E : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
(P : CategoryTheory.Functor Cᵒᵖ D) (e : C ≌ E),
CategoryTheory.regularTopology.EqualizerCondition P ↔
CategoryTheory.regu... | true |
IsNoetherian.finsetBasisIndex | Mathlib.FieldTheory.Finiteness | (K : Type u) →
(V : Type v) →
[inst : DivisionRing K] → [inst_1 : AddCommGroup V] → [inst_2 : Module K V] → [IsNoetherian K V] → Finset V | true |
AddSemiconjBy.neg_symm_left_iff._simp_1 | Mathlib.Algebra.Group.Semiconj.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {a x y : G}, AddSemiconjBy (-a) y x = AddSemiconjBy a x y | false |
CategoryTheory.Coyoneda.colimitCoconeIsColimit._proof_2 | Mathlib.CategoryTheory.Limits.Yoneda | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : Cᵒᵖ)
(s : CategoryTheory.Limits.Cocone (CategoryTheory.coyoneda.obj X))
(m : (CategoryTheory.Coyoneda.colimitCocone X).pt ⟶ s.pt),
(∀ (j : C), CategoryTheory.CategoryStruct.comp ((CategoryTheory.Coyoneda.colimitCocone X).ι.app j) m = s.ι.app j) →... | false |
Std.DTreeMap.Raw.maxKeyD_insertIfNew | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF →
∀ {k : α} {v : β k} {fallback : α},
(t.insertIfNew k v).maxKeyD fallback = t.maxKey?.elim k fun k' => if cmp k' k = Ordering.lt then k else k' | true |
CategoryTheory.CartesianMonoidalCategory.mk | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[toSemiCartesianMonoidalCategory : CategoryTheory.SemiCartesianMonoidalCategory C] →
((X Y : C) →
CategoryTheory.Limits.IsLimit
(CategoryTheory.Limits.BinaryFan.mk (CategoryTheory.SemiCartesianMonoidalCategory.fst X Y)
... | true |
Module.Basis.ofIsCoprimeDifferentIdeal._proof_10 | Mathlib.RingTheory.DedekindDomain.LinearDisjoint | ∀ (A : Type u_3) {K : Type u_4} {L : Type u_2} [inst : CommRing A] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra K L] (R₂ : Type u_1) [inst_4 : CommRing R₂] [inst_5 : Algebra A R₂] [Module.Finite A R₂]
{F₂ : IntermediateField K L} [inst_7 : Algebra R₂ ↥F₂] [IsDomain A] [IsDedekindDomain R₂] [IsFractionRin... | false |
AlgHom.liftOfSurjective._proof_2 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B), (RingHom.ker f.toRingHom).IsTwoSided | false |
Std.HashMap.Equiv.filterMap | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashMap α β}
(f : α → β → Option γ), m₁.Equiv m₂ → (Std.HashMap.filterMap f m₁).Equiv (Std.HashMap.filterMap f m₂) | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxsOf_lt._proof_1_19 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ} {xs : List α} {x : α} {s : ℕ} [inst : BEq α] (h : i < (List.idxsOf x xs s).length),
(List.findIdxs (fun x_1 => x_1 == x) xs)[0] + 1 ≤ xs.length → (List.findIdxs (fun x_1 => x_1 == x) xs)[0] < xs.length | false |
CategoryTheory.CartesianMonoidalCategory.lift_leftUnitor_hom | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C] {X Y : C}
(f : X ⟶ CategoryTheory.MonoidalCategoryStruct.tensorUnit C) (g : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CartesianMonoidalCategory.lift f g)
(CategoryTheory.MonoidalCate... | true |
Array.find?_isSome | Init.Data.Array.Find | ∀ {α : Type u_1} {xs : Array α} {p : α → Bool}, (Array.find? p xs).isSome = true ↔ ∃ x ∈ xs, p x = true | true |
Std.LawfulEqCmp.opposite | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.OrientedCmp cmp] [Std.LawfulEqCmp cmp], Std.LawfulEqCmp fun a b => cmp b a | true |
FreeAbelianGroup.ring._proof_4 | Mathlib.GroupTheory.FreeAbelianGroup | ∀ (α : Type u_1) [inst : Monoid α] (n : ℕ), (n + 1).unaryCast = n.unaryCast + 1 | false |
_private.Std.Sat.AIG.RelabelNat.0.Std.Sat.AIG.RelabelNat.State.ofAIGAux.go.match_1.splitter | Std.Sat.AIG.RelabelNat | {α : Type} →
(motive : Std.Sat.AIG.Decl α → Sort u_1) →
(decl : Std.Sat.AIG.Decl α) →
((a : α) → decl = Std.Sat.AIG.Decl.atom a → motive (Std.Sat.AIG.Decl.atom a)) →
(decl = Std.Sat.AIG.Decl.false → motive Std.Sat.AIG.Decl.false) →
((lhs rhs : Std.Sat.AIG.Fanin) →
decl = Std.... | true |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.instRxcLawfulHasSize._proof_3 | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ (n : ℕ), ¬n + 1 > 0 → False | false |
mem_openSegment_iff_div | Mathlib.Analysis.Convex.Segment | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Semifield 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {x y z : E},
x ∈ openSegment 𝕜 y z ↔ ∃ a b, 0 < a ∧ 0 < b ∧ (a / (a + b)) • y + (b / (a + b)) • z = x | true |
Batteries.RBNode.depth.eq_def | Batteries.Data.RBMap.Depth | ∀ {α : Type u_1} (x : Batteries.RBNode α),
x.depth =
match x with
| Batteries.RBNode.nil => 0
| Batteries.RBNode.node c a v b => max a.depth b.depth + 1 | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.