name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Represents.0.SimpleGraph.ConnectedComponent.Represents.existsUnique_rep._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Represents | ∀ {V : Type u} {G : SimpleGraph V} (C : G.ConnectedComponent) (v : V), (v ∈ C.supp) = (G.connectedComponentMk v = C) | false |
Fin.exists_iff_exists_maximal | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ} (p : Fin n → Prop) [DecidablePred p], (∃ i, p i) ↔ ∃ i, p i ∧ ∀ (j : Fin n), i < j → ¬p j | true |
_private.Mathlib.NumberTheory.Fermat.0.Nat.coprime_fermatNumber_fermatNumber._simp_1_1 | Mathlib.NumberTheory.Fermat | ∀ {n m : ℕ}, n.Coprime m = m.Coprime n | false |
Lean.PersistentArray.foldrM | Lean.Data.PersistentArray | {α : Type u} → {m : Type v → Type w} → {β : Type v} → [Monad m] → Lean.PersistentArray α → (α → β → m β) → β → m β | true |
_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.MessageOverview.rpcRequest.inj | Lean.Server.ProtocolOverview | ∀ {o o_1 : Lean.Server.Overview.RpcRequestOverview✝},
Lean.Server.Overview.MessageOverview.rpcRequest✝ o = Lean.Server.Overview.MessageOverview.rpcRequest✝¹ o_1 → o = o_1 | true |
Lean.Elab.ComputedFields.Context.toInductiveVal | Lean.Elab.ComputedFields | Lean.Elab.ComputedFields.Context → Lean.InductiveVal | true |
ciSup_mono' | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLinearOrderBot α] {ι' : Sort u_5} {f : ι → α} {g : ι' → α},
BddAbove (Set.range g) → (∀ (i : ι), ∃ i', f i ≤ g i') → iSup f ≤ iSup g | true |
Lean.Elab.Term.Do.ToTerm.Context.ctorIdx | Lean.Elab.Do.Legacy | Lean.Elab.Term.Do.ToTerm.Context → ℕ | false |
ProbabilityTheory.cond_eq_zero_of_meas_eq_zero | Mathlib.Probability.ConditionalProbability | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {s : Set Ω}, μ s = 0 → μ[|s] = 0 | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal.0.Polynomial.Chebyshev.negOnePow_mul_iterateDerivativeC_pos._proof_1_8 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal | ∀ (s : Finset ℕ), 0 ∉ s → ∀ a ∈ s, 0 < a | false |
Nat.lt_add_one_iff | Init.Data.Nat.Basic | ∀ {m n : ℕ}, m < n + 1 ↔ m ≤ n | true |
Batteries.CodeAction.isMatchTerm.match_1 | Batteries.CodeAction.Match | (motive : Lean.Elab.Info → Sort u_1) →
(x : Lean.Elab.Info) →
((i : Lean.Elab.TermInfo) → motive (Lean.Elab.Info.ofTermInfo i)) → ((x : Lean.Elab.Info) → motive x) → motive x | false |
Bundle.ContinuousLinearMap.fiberBundle | Mathlib.Topology.VectorBundle.Hom | {𝕜₁ : Type u_1} →
[inst : NontriviallyNormedField 𝕜₁] →
{𝕜₂ : Type u_2} →
[inst_1 : NontriviallyNormedField 𝕜₂] →
(σ : 𝕜₁ →+* 𝕜₂) →
{B : Type u_3} →
(F₁ : Type u_4) →
[inst_2 : NormedAddCommGroup F₁] →
[inst_3 : NormedSpace 𝕜₁ F₁] →
(E₁ : B → Type u_5) →
[inst_4 : (x : B) → AddCommGroup (E₁ x)] →
[inst_5 : (x : B) → Module 𝕜₁ (E₁ x)] →
[inst_6 : TopologicalSpace (Bundle.TotalSpace F₁ E₁)] →
(F₂ : Type u_6) →
[inst_7 : NormedAddCommGroup F₂] →
[inst_8 : NormedSpace 𝕜₂ F₂] →
(E₂ : B → Type u_7) →
[inst_9 : (x : B) → AddCommGroup (E₂ x)] →
[inst_10 : (x : B) → Module 𝕜₂ (E₂ x)] →
[inst_11 : TopologicalSpace (Bundle.TotalSpace F₂ E₂)] →
[inst_12 : TopologicalSpace B] →
[inst_13 : (x : B) → TopologicalSpace (E₁ x)] →
[inst_14 : FiberBundle F₁ E₁] →
[inst_15 : VectorBundle 𝕜₁ F₁ E₁] →
[inst_16 : (x : B) → TopologicalSpace (E₂ x)] →
[inst_17 : FiberBundle F₂ E₂] →
[inst_18 : VectorBundle 𝕜₂ F₂ E₂] →
[inst_19 : ∀ (x : B), IsTopologicalAddGroup (E₂ x)] →
[inst_20 : ∀ (x : B), ContinuousSMul 𝕜₂ (E₂ x)] →
[inst_21 : RingHomIsometric σ] →
FiberBundle (F₁ →SL[σ] F₂) fun x => E₁ x →SL[σ] E₂ x | true |
AlgebraicGeometry.LocallyRingedSpace.restrictTopIso | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | (X : AlgebraicGeometry.LocallyRingedSpace) → X.restrict ⋯ ≅ X | true |
_private.Mathlib.Algebra.TrivSqZeroExt.Basic.0.TrivSqZeroExt.isUnit_inv_iff._simp_1_1 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u} {M : Type v} [inst : AddCommGroup M] [inst_1 : Semiring R] [inst_2 : Module Rᵐᵒᵖ M] [inst_3 : Module R M]
[inst_4 : SMulCommClass R Rᵐᵒᵖ M] {x : TrivSqZeroExt R M}, IsUnit x = IsUnit x.fst | false |
IsGreatest.eq_1 | Mathlib.Order.Bounds.Defs | ∀ {α : Type u_1} [inst : LE α] (s : Set α) (a : α), IsGreatest s a = (a ∈ s ∧ a ∈ upperBounds s) | true |
MulOpposite.unop_comp_op | Mathlib.Algebra.Opposites | ∀ {α : Type u_1}, MulOpposite.unop ∘ MulOpposite.op = id | true |
Configuration.HasPoints.mkPoint | Mathlib.Combinatorics.Configuration | {P : Type u_1} →
{L : Type u_2} → {inst : Membership P L} → [self : Configuration.HasPoints P L] → {l₁ l₂ : L} → l₁ ≠ l₂ → P | true |
_private.Mathlib.Topology.UniformSpace.CompactConvergence.0.ContinuousMap.instIsCountablyGeneratedProdUniformityOfWeaklyLocallyCompactSpaceOfSigmaCompactSpace.match_1 | Mathlib.Topology.UniformSpace.CompactConvergence | ∀ {β : Type u_1} [inst : UniformSpace β] (motive : (∃ x, (uniformity β).HasAntitoneBasis x) → Prop)
(x : ∃ x, (uniformity β).HasAntitoneBasis x),
(∀ (_V : ℕ → Set (β × β)) (hV : (uniformity β).HasAntitoneBasis _V), motive ⋯) → motive x | false |
Lean.Elab.Term.FixedTermElabRef.toFixedTermElabImpl | Lean.Elab.Term.TermElabM | Lean.Elab.Term.FixedTermElabRef → Lean.Elab.Term.FixedTermElab | true |
DFinsupp.instAdd._proof_1 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_2} {β : ι → Type u_1} [inst : (i : ι) → AddZeroClass (β i)] (x : ι), 0 + 0 = 0 | false |
Lean.Parser.Term.throwNamedErrorMacro._regBuiltin.Lean.Parser.Term.throwNamedErrorMacro.formatter_7 | Lean.Parser.Term | IO Unit | false |
Finsupp.cons_right_injective | Mathlib.Data.Finsupp.Fin | ∀ {n : ℕ} {M : Type u_2} [inst : Zero M] (y : M), Function.Injective (Finsupp.cons y) | true |
Lean.Server.RefInfo.mk.injEq | Lean.Server.References | ∀ (definition : Option Lean.Server.Reference) (usages : Array Lean.Server.Reference)
(definition_1 : Option Lean.Server.Reference) (usages_1 : Array Lean.Server.Reference),
({ definition := definition, usages := usages } = { definition := definition_1, usages := usages_1 }) =
(definition = definition_1 ∧ usages = usages_1) | true |
Subsemigroup.ext | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_1} [inst : Mul M] {S T : Subsemigroup M}, (∀ (x : M), x ∈ S ↔ x ∈ T) → S = T | true |
UniqueFactorizationMonoid.factors | Mathlib.RingTheory.UniqueFactorizationDomain.Defs | {α : Type u_1} → [inst : CommMonoidWithZero α] → [UniqueFactorizationMonoid α] → α → Multiset α | true |
_private.Init.Data.Nat.SOM.0.Nat.SOM.Poly.add.go.match_1.splitter | Init.Data.Nat.SOM | (motive : Nat.SOM.Poly → Nat.SOM.Poly → Sort u_1) →
(p₁ p₂ : Nat.SOM.Poly) →
((p₁ : Nat.SOM.Poly) → motive p₁ []) →
((p₂ : Nat.SOM.Poly) → (p₂ = [] → False) → motive [] p₂) →
((k₁ : ℕ) →
(m₁ : Nat.SOM.Mon) →
(p₁ : List (ℕ × Nat.SOM.Mon)) →
(k₂ : ℕ) →
(m₂ : Nat.SOM.Mon) → (p₂ : List (ℕ × Nat.SOM.Mon)) → motive ((k₁, m₁) :: p₁) ((k₂, m₂) :: p₂)) →
motive p₁ p₂ | true |
_private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.getElem!_toList_roc_ne_zero_iff._proof_1_2 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ} {i : ℕ}, ¬(i < (n - m).toNat ∧ m + 1 + ↑i ≠ 0 ↔ i < (n - m).toNat ∧ m + ↑i ≠ -1) → False | false |
Submodule.mem_orthogonalBilin_iff._simp_1 | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {R₁ : Type u_2} {M : Type u_5} {M₁ : Type u_6} [inst : CommRing R] [inst_1 : CommRing R₁]
[inst_2 : AddCommGroup M₁] [inst_3 : Module R₁ M₁] [inst_4 : AddCommGroup M] [inst_5 : Module R M] {I₁ I₂ : R₁ →+* R}
{B : M₁ →ₛₗ[I₁] M₁ →ₛₗ[I₂] M} {N : Submodule R₁ M₁} {m : M₁}, (m ∈ N.orthogonalBilin B) = ∀ n ∈ N, B.IsOrtho n m | false |
WithBot.range_eq | Mathlib.Order.Set | ∀ {α : Type u_1} {β : Type u_2} (f : WithBot α → β), Set.range f = insert (f ⊥) (Set.range (f ∘ WithBot.some)) | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.perm_filter_containsKey_of_perm._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} (a : α) {l₁ l₂ : List α}, (a :: l₁).Perm (a :: l₂) = l₁.Perm l₂ | false |
Std.Tactic.BVDecide.instDecidableEqBVUnOp.decEq._proof_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ (a : ℕ), Std.Tactic.BVDecide.BVUnOp.rotateRight a = Std.Tactic.BVDecide.BVUnOp.rotateRight a | false |
legendreSym.eq_neg_one_iff_not_one | Mathlib.NumberTheory.LegendreSymbol.Basic | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] {a : ℤ}, ↑a ≠ 0 → (legendreSym p a = -1 ↔ ¬legendreSym p a = 1) | true |
StrictMono.neg | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} {β : Type u_1} [inst : AddGroup α] [inst_1 : Preorder α] [AddLeftStrictMono α] [AddRightStrictMono α]
[inst_4 : Preorder β] {f : β → α}, StrictMono f → StrictAnti fun x => -f x | true |
Commute.mul_inv_cancel_assoc | Mathlib.Algebra.Group.Commute.Defs | ∀ {G : Type u_1} [inst : Group G] {a b : G}, Commute a b → a * (b * a⁻¹) = b | true |
Valued.integer.exists_norm_lt_one | Mathlib.Topology.Algebra.Valued.LocallyCompact | ∀ (K : Type u_1) [inst : NontriviallyNormedField K] [inst_1 : IsUltrametricDist K], ∃ x, 0 < ‖x‖ ∧ ‖x‖ < 1 | true |
_private.Batteries.Data.String.Lemmas.0.String.Pos.Raw.Valid.exists.match_1_1 | Batteries.Data.String.Lemmas | ∀ (motive : (x : String) → (x_1 : String.Pos.Raw) → String.Pos.Raw.Valid x x_1 → Prop) (x : String)
(x_1 : String.Pos.Raw) (x_2 : String.Pos.Raw.Valid x x_1),
(∀ (cs cs' : List Char), motive (String.ofList (cs ++ cs')) { byteIdx := String.utf8Len cs } ⋯) → motive x x_1 x_2 | false |
_private.Lean.Environment.0.Lean.Environment.ConstPromiseVal._sizeOf_inst | Lean.Environment | SizeOf Lean.Environment.ConstPromiseVal✝ | false |
WittVector.hasNatPow | Mathlib.RingTheory.WittVector.Defs | {p : ℕ} → {R : Type u_1} → [hp : Fact (Nat.Prime p)] → [CommRing R] → Pow (WittVector p R) ℕ | true |
Std.DHashMap.Internal.Raw₀.isHashSelf_reinsertAux | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α]
(data : { d // 0 < d.size }) (a : α) (b : β a),
Std.DHashMap.Internal.IsHashSelf ↑data →
Std.DHashMap.Internal.IsHashSelf ↑(Std.DHashMap.Internal.Raw₀.reinsertAux hash data a b) | true |
toPullbackDiag | Mathlib.Data.Set.Prod | {X : Type u_1} → {Y : Sort u_2} → (f : X → Y) → X → Function.Pullback f f | true |
USize.toUInt16_shiftLeft_mod | Init.Data.UInt.Bitwise | ∀ (a b : USize), (a <<< (b % 16)).toUInt16 = a.toUInt16 <<< b.toUInt16 | true |
Order.cof_ord_cof | Mathlib.SetTheory.Cardinal.Cofinality | ∀ (α : Type u_1) [inst : LinearOrder α] [WellFoundedLT α], (Order.cof α).ord.cof = Order.cof α | true |
Std.DTreeMap.Internal.Impl.get_filterMap | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {γ : α → Type w}
[inst : Std.TransOrd α] [inst_1 : Std.LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} {k : α} (h : t.WF)
{h' : k ∈ (Std.DTreeMap.Internal.Impl.filterMap f t ⋯).impl},
(Std.DTreeMap.Internal.Impl.filterMap f t ⋯).impl.get k h' = (f k (t.get k ⋯)).get ⋯ | true |
Matroid.IsRkFinite.union | Mathlib.Combinatorics.Matroid.Rank.Finite | ∀ {α : Type u_1} {M : Matroid α} {X Y : Set α}, M.IsRkFinite X → M.IsRkFinite Y → M.IsRkFinite (X ∪ Y) | true |
Orientation.oangle_eq_angle_of_sign_eq_one | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) {x y : V}, (o.oangle x y).sign = 1 → o.oangle x y = ↑(InnerProductGeometry.angle x y) | true |
CategoryTheory.Limits.binaryBiconeOfIsSplitEpiOfKernel | Mathlib.CategoryTheory.Preadditive.Biproducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{X Y : C} →
{f : X ⟶ Y} →
[CategoryTheory.IsSplitEpi f] →
{c : CategoryTheory.Limits.KernelFork f} →
CategoryTheory.Limits.IsLimit c → CategoryTheory.Limits.BinaryBicone c.pt Y | true |
IsSMulRegular.rTensor | Mathlib.RingTheory.Regular.IsSMulRegular | ∀ {R : Type u_1} (M : Type u_3) {M' : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup M']
[inst_3 : Module R M] [inst_4 : Module R M'] [Module.Flat R M] {r : R},
IsSMulRegular M' r → IsSMulRegular (TensorProduct R M' M) r | true |
CategoryTheory.Limits.Cofan.isColimitTrans._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {α : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {X : α → C}
(c : CategoryTheory.Limits.Cofan X) (hc : CategoryTheory.Limits.IsColimit c) {β : α → Type u_1}
{Y : (a : α) → β a → C} (π : (a : α) → (b : β a) → Y a b ⟶ X a)
(hs : (a : α) → CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.Cofan.mk (X a) (π a)))
(t :
CategoryTheory.Limits.Cofan fun x =>
match x with
| ⟨a, b⟩ => Y a b)
(h : (a : α) × β a),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Limits.Cofan.mk c.pt fun x =>
match x with
| ⟨a, b⟩ => CategoryTheory.CategoryStruct.comp (π a b) (c.inj a)).inj
h)
(hc.desc
(CategoryTheory.Limits.Cofan.mk t.1 fun a =>
(hs a).desc (CategoryTheory.Limits.Cofan.mk t.pt fun b => t.inj ⟨a, b⟩))) =
t.inj h | false |
Lean.Elab.Tactic.Omega.instToExprLinearCombo | Lean.Elab.Tactic.Omega.Core | Lean.ToExpr Lean.Omega.LinearCombo | true |
Std.Time.Duration.instHMulInt_1 | Std.Time.Duration | HMul Std.Time.Duration ℤ Std.Time.Duration | true |
Hyperreal.instField._aux_8 | Mathlib.Analysis.Real.Hyperreal | ℕ → ℝ* → ℝ* | false |
_private.Mathlib.LinearAlgebra.Determinant.0.LinearEquiv.det_mul_det_symm._simp_1_1 | Mathlib.LinearAlgebra.Determinant | ∀ {M : Type u_2} [inst : AddCommGroup M] {A : Type u_5} [inst_1 : CommRing A] [inst_2 : Module A M] (f g : M →ₗ[A] M),
LinearMap.det f * LinearMap.det g = LinearMap.det (f ∘ₗ g) | false |
AddGrpCat.Hom.ext | Mathlib.Algebra.Category.Grp.Basic | ∀ {A B : AddGrpCat} {x y : A.Hom B}, x.hom' = y.hom' → x = y | true |
RingCon.instFunLikeForallProp._proof_1 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : Add R] [inst_1 : Mul R], Function.Injective ((fun f => ⇑f) ∘ fun c => c.toCon) | false |
Subsemigroup.map_strictMono_of_injective | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] {f : M →ₙ* N},
Function.Injective ⇑f → StrictMono (Subsemigroup.map f) | true |
_private.Mathlib.Algebra.Module.ZLattice.Basic.0.ZSpan.fundamentalDomain_measurableSet._simp_1_2 | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Ico a b) = (a ≤ x ∧ x < b) | false |
Ordinal.enumOrd_univ | Mathlib.SetTheory.Ordinal.Enum | Ordinal.enumOrd Set.univ = id | true |
Lean.Parser.Term.tuple._regBuiltin.Lean.Parser.Term.tuple.parenthesizer_13 | Lean.Parser.Term | IO Unit | false |
MonoidAlgebra.mapDomainRingEquiv._proof_4 | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {M : Type u_1} {N : Type u_2} [inst : Monoid M] [inst_1 : Monoid N], MonoidHomClass (N ≃* M) N M | false |
_private.Mathlib.Order.RelIso.Basic.0.RelHomClass.irrefl.match_1_1 | Mathlib.Order.RelIso.Basic | ∀ {β : Type u_1} {s : β → β → Prop} (motive : Std.Irrefl s → Prop) (x : Std.Irrefl s),
(∀ (H : ∀ (a : β), ¬s a a), motive ⋯) → motive x | false |
Hamming.instPseudoMetricSpace._proof_1 | Mathlib.InformationTheory.Hamming | ∀ {ι : Type u_2} {β : ι → Type u_1} [inst : Fintype ι] [inst_1 : (i : ι) → DecidableEq (β i)] (x y : Hamming β),
0 ≤ dist x y | false |
Int.mul_lt_mul_right_of_neg | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, a < 0 → (b * a < c * a ↔ c < b) | true |
Std.TreeSet.get?_ofList_of_mem | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {l : List α} {k k' : α},
cmp k k' = Ordering.eq →
List.Pairwise (fun a b => ¬cmp a b = Ordering.eq) l → k ∈ l → (Std.TreeSet.ofList l cmp).get? k' = some k | true |
HVertexOperator.coeff._proof_1 | Mathlib.Algebra.Vertex.HVertexOperator | ∀ {Γ : Type u_2} [inst : PartialOrder Γ] {R : Type u_3} {V : Type u_4} {W : Type u_1} [inst_1 : CommRing R]
[inst_2 : AddCommGroup V] [inst_3 : Module R V] [inst_4 : AddCommGroup W] [inst_5 : Module R W]
(A : HVertexOperator Γ R V W) (n : Γ) (u v : V),
((HahnModule.of R).symm (A (u + v))).coeff n =
((HahnModule.of R).symm (A u)).coeff n + ((HahnModule.of R).symm (A v)).coeff n | false |
OrderEmbedding.coe_ofMapLEIff | Mathlib.Order.Hom.Basic | ∀ {α : Type u_6} {β : Type u_7} [inst : PartialOrder α] [inst_1 : Preorder β] {f : α → β}
(h : ∀ (a b : α), f a ≤ f b ↔ a ≤ b), ⇑(OrderEmbedding.ofMapLEIff f h) = f | true |
PProd.forall._simp_1 | Mathlib.Data.Prod.PProd | ∀ {α : Sort u_1} {β : Sort u_2} {p : α ×' β → Prop}, (∀ (x : α ×' β), p x) = ∀ (a : α) (b : β), p ⟨a, b⟩ | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.resRec.match_3.splitter | Init.Data.BitVec.Bitblast | {w : ℕ} →
(motive : (s : ℕ) → s < w → 0 < s → Sort u_1) →
(s : ℕ) →
(hs : s < w) →
(hslt : 0 < s) →
((hs : 0 < w) → (hslt : 0 < 0) → s = 0 → motive 0 hs hslt) →
((s' : ℕ) → (hs : s' + 1 < w) → (hslt : 0 < s' + 1) → s = s'.succ → motive s'.succ hs hslt) →
motive s hs hslt | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceR!.match_1.eq_5 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (motive : Std.DTreeMap.Internal.Impl α β → Sort u_3) (rs : ℕ) (rk : α) (rv : β rk)
(rls : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β) (size : ℕ) (k_1 : α) (v_1 : β k_1)
(l_1 r_1 : Std.DTreeMap.Internal.Impl α β) (h_1 : Unit → motive Std.DTreeMap.Internal.Impl.leaf)
(h_2 :
(size : ℕ) →
(k : α) →
(v : β k) →
motive
(Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf))
(h_3 :
(size : ℕ) →
(rk : α) →
(rv : β rk) →
(rr : Std.DTreeMap.Internal.Impl α β) →
(size_1 : ℕ) →
(k : α) →
(v : β k) →
(l r : Std.DTreeMap.Internal.Impl α β) →
rr = Std.DTreeMap.Internal.Impl.inner size_1 k v l r →
motive
(Std.DTreeMap.Internal.Impl.inner size rk rv Std.DTreeMap.Internal.Impl.leaf
(Std.DTreeMap.Internal.Impl.inner size_1 k v l r)))
(h_4 :
(size : ℕ) →
(rk : α) →
(rv : β rk) →
(size_1 : ℕ) →
(rlk : α) →
(rlv : β rlk) →
(l r : Std.DTreeMap.Internal.Impl α β) →
motive
(Std.DTreeMap.Internal.Impl.inner size rk rv (Std.DTreeMap.Internal.Impl.inner size_1 rlk rlv l r)
Std.DTreeMap.Internal.Impl.leaf))
(h_5 :
(rs : ℕ) →
(rk : α) →
(rv : β rk) →
(rl : Std.DTreeMap.Internal.Impl α β) →
(rls : ℕ) →
(k : α) →
(v : β k) →
(l r : Std.DTreeMap.Internal.Impl α β) →
rl = Std.DTreeMap.Internal.Impl.inner rls k v l r →
(rr : Std.DTreeMap.Internal.Impl α β) →
(size : ℕ) →
(k_2 : α) →
(v_2 : β k_2) →
(l_2 r_2 : Std.DTreeMap.Internal.Impl α β) →
rr = Std.DTreeMap.Internal.Impl.inner size k_2 v_2 l_2 r_2 →
motive
(Std.DTreeMap.Internal.Impl.inner rs rk rv
(Std.DTreeMap.Internal.Impl.inner rls k v l r)
(Std.DTreeMap.Internal.Impl.inner size k_2 v_2 l_2 r_2))),
(match
Std.DTreeMap.Internal.Impl.inner rs rk rv (Std.DTreeMap.Internal.Impl.inner rls k v l r)
(Std.DTreeMap.Internal.Impl.inner size k_1 v_1 l_1 r_1) with
| Std.DTreeMap.Internal.Impl.leaf => h_1 ()
| Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf =>
h_2 size k v
|
Std.DTreeMap.Internal.Impl.inner size rk rv Std.DTreeMap.Internal.Impl.leaf
rr@h:(Std.DTreeMap.Internal.Impl.inner size_1 k v l r) =>
h_3 size rk rv rr size_1 k v l r h
|
Std.DTreeMap.Internal.Impl.inner size rk rv (Std.DTreeMap.Internal.Impl.inner size_1 rlk rlv l r)
Std.DTreeMap.Internal.Impl.leaf =>
h_4 size rk rv size_1 rlk rlv l r
|
Std.DTreeMap.Internal.Impl.inner rs rk rv (rl@h:(Std.DTreeMap.Internal.Impl.inner rls k v l r))
rr@h_6:(Std.DTreeMap.Internal.Impl.inner size k_2 v_2 l_2 r_2) =>
h_5 rs rk rv rl rls k v l r h rr size k_2 v_2 l_2 r_2 h_6) =
h_5 rs rk rv (Std.DTreeMap.Internal.Impl.inner rls k v l r) rls k v l r ⋯
(Std.DTreeMap.Internal.Impl.inner size k_1 v_1 l_1 r_1) size k_1 v_1 l_1 r_1 ⋯ | true |
finsum_congr_Prop | Mathlib.Algebra.BigOperators.Finprod | ∀ {M : Type u_2} [inst : AddCommMonoid M] {p q : Prop} {f : p → M} {g : q → M} (hpq : p = q),
(∀ (h : q), f ⋯ = g h) → finsum f = finsum g | true |
Rat.instCharZero | Mathlib.Algebra.Ring.Rat | CharZero ℚ | true |
_private.Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn.0.MeasureTheory.SignedMeasure.exists_compl_positive_negative.match_1_1 | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn | ∀ {α : Type u_1} [inst : MeasurableSpace α] (s : MeasureTheory.SignedMeasure α) (B : ℕ → Set α) (m : ℕ)
(motive :
B m ∈ {B | MeasurableSet B ∧ MeasureTheory.VectorMeasure.restrict s B ≤ MeasureTheory.VectorMeasure.restrict 0 B} →
Prop)
(x :
B m ∈ {B | MeasurableSet B ∧ MeasureTheory.VectorMeasure.restrict s B ≤ MeasureTheory.VectorMeasure.restrict 0 B}),
(∀ (left : MeasurableSet (B m))
(h : MeasureTheory.VectorMeasure.restrict s (B m) ≤ MeasureTheory.VectorMeasure.restrict 0 (B m)), motive ⋯) →
motive x | false |
Metric.contractibleSpace_eball | Mathlib.Analysis.Normed.Module.Connected | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [NormedSpace ℝ E] {x : E} {r : ENNReal},
0 < r → ContractibleSpace ↑(Metric.eball x r) | true |
Std.HashSet.fold | Std.Data.HashSet.Basic | {α : Type u} → {x : BEq α} → {x_1 : Hashable α} → {β : Type v} → (β → α → β) → β → Std.HashSet α → β | true |
isLeftRegular_toLex._simp_2 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : Monoid α] {a : α}, IsLeftRegular (toLex a) = IsLeftRegular a | false |
TypeVec.prod.mk | Mathlib.Data.TypeVec | {n : ℕ} → {α β : TypeVec.{u} n} → (i : Fin2 n) → α i → β i → α.prod β i | true |
AlgebraicGeometry.instIsMultiplicativeSchemeIsAffineHom | Mathlib.AlgebraicGeometry.Morphisms.Affine | CategoryTheory.MorphismProperty.IsMultiplicative @AlgebraicGeometry.IsAffineHom | true |
OrderEmbedding.isWellOrder | Mathlib.Order.Hom.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [IsWellOrder β fun x1 x2 => x1 < x2]
(f : α ↪o β), IsWellOrder α fun x1 x2 => x1 < x2 | true |
OmegaCompletePartialOrder.ωScottContinuous.of_apply₂ | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} {γ : Type u_4} {β : α → Type u_6} [inst : (x : α) → OmegaCompletePartialOrder (β x)]
[inst_1 : OmegaCompletePartialOrder γ] {f : γ → (x : α) → β x},
(∀ (a : α), OmegaCompletePartialOrder.ωScottContinuous fun x => f x a) → OmegaCompletePartialOrder.ωScottContinuous f | true |
Lean.Expr.NumObjs.State.mk._flat_ctor | Lean.Util.NumObjs | Lean.PtrSet Lean.Expr → ℕ → Lean.Expr.NumObjs.State | false |
_private.Mathlib.Analysis.Normed.Group.Continuity.0.controlled_prod_of_mem_closure._simp_1_6 | Mathlib.Analysis.Normed.Group.Continuity | ∀ {α : Type u_1} [inst : DivisionMonoid α] (a : α) (m n : ℤ), (a ^ m) ^ n = a ^ (m * n) | false |
ContinuousAffineEquiv.constVAdd | Mathlib.Topology.Algebra.ContinuousAffineEquiv | (k : Type u_1) →
(P₁ : Type u_2) →
{V₁ : Type u_6} →
[inst : Ring k] →
[inst_1 : AddCommGroup V₁] →
[inst_2 : Module k V₁] →
[inst_3 : AddTorsor V₁ P₁] → [inst_4 : TopologicalSpace P₁] → [ContinuousConstVAdd V₁ P₁] → V₁ → P₁ ≃ᴬ[k] P₁ | true |
Perfection.liftMonoidHom | Mathlib.RingTheory.Perfection | (p : ℕ) →
(M : Type u_2) →
[inst : CommMonoid M] →
[PerfectRing M p] → (N : Type u_3) → [inst_2 : CommMonoid N] → (M →* N) ≃* (M →* Perfection N p) | true |
Lean.BaseMessage.endPos._default | Lean.Message | {α : Type u} → Option Lean.Position | false |
Lean.Meta.Origin.stx.elim | Lean.Meta.Tactic.Simp.SimpTheorems | {motive : Lean.Meta.Origin → Sort u} →
(t : Lean.Meta.Origin) →
t.ctorIdx = 2 → ((id : Lean.Name) → (ref : Lean.Syntax) → motive (Lean.Meta.Origin.stx id ref)) → motive t | false |
CategoryTheory.SmallObject.llp_rlp_ιObj | Mathlib.CategoryTheory.SmallObject.IsCardinalForSmallObjectArgument | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (I : CategoryTheory.MorphismProperty C) (κ : Cardinal.{w})
[inst_1 : Fact κ.IsRegular] [inst_2 : OrderBot κ.ord.ToType] [inst_3 : I.IsCardinalForSmallObjectArgument κ] {X Y : C}
(f : X ⟶ Y), I.rlp.llp (CategoryTheory.SmallObject.ιObj I κ f) | true |
DirectLimit.instRingOfRingHomClass._proof_8 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] {G : ι → Type u_1} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (i : ι) → Ring (G i)] [inst_6 : ∀ (i j : ι) (h : i ≤ j), RingHomClass (T h) (G i) (G j)] (n : ℕ),
IntCast.intCast (Int.negSucc n) = -↑(n + 1) | false |
Congr!.Config.useCongrSimp | Mathlib.Tactic.CongrExclamation | Congr!.Config → Bool | true |
Std.DTreeMap.Internal.Const.RcoSliceData.mk.sizeOf_spec | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {β : Type v} [inst : Ord α] [inst_1 : SizeOf α] [inst_2 : SizeOf β]
(treeMap : Std.DTreeMap.Internal.Impl α fun x => β) (range : Std.Rco α),
sizeOf { treeMap := treeMap, range := range } = 1 + sizeOf treeMap + sizeOf range | true |
_private.Mathlib.Data.Sym.Sym2.0.Sym2.perm_card_two_iff._simp_1_7 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {a b : α} (m : Multiset α), ({a} = b ::ₘ m) = (a = b ∧ m = 0) | false |
CategoryTheory.Presieve.IsSheafFor | Mathlib.CategoryTheory.Sites.IsSheafFor | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X : C} → CategoryTheory.Functor Cᵒᵖ (Type w) → CategoryTheory.Presieve X → Prop | true |
CategoryTheory.Limits.HasColimit.mk' | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor J C},
Nonempty (CategoryTheory.Limits.ColimitCocone F) → CategoryTheory.Limits.HasColimit F | true |
Nat.factorization_mul_apply_of_coprime | Mathlib.Data.Nat.Factorization.Defs | ∀ {p a b : ℕ}, a.Coprime b → (a * b).factorization p = a.factorization p + b.factorization p | true |
TwoSidedIdeal.sub_mem | Mathlib.RingTheory.TwoSidedIdeal.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (I : TwoSidedIdeal R) {x y : R}, x ∈ I → y ∈ I → x - y ∈ I | true |
mulTSupport | Mathlib.Topology.Algebra.Support | {X : Type u_1} → {α : Type u_2} → [One α] → [TopologicalSpace X] → (X → α) → Set X | true |
_private.Mathlib.RingTheory.FractionalIdeal.Operations.0.FractionalIdeal.isFractional_span_iff.match_1_1 | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
{s : Set P} (motive : IsFractional S (Submodule.span R s) → Prop) (x : IsFractional S (Submodule.span R s)),
(∀ (a : R) (a_mem : a ∈ S) (h : ∀ b ∈ Submodule.span R s, IsLocalization.IsInteger R (a • b)), motive ⋯) → motive x | false |
Lean.Lsp.CreateFile.mk._flat_ctor | Lean.Data.Lsp.Basic | Lean.Lsp.DocumentUri → Option Lean.Lsp.CreateFile.Options → Option String → Lean.Lsp.CreateFile | false |
_private.Lean.Compiler.ExternAttr.0.Lean.instBEqExternEntry.beq.match_1 | Lean.Compiler.ExternAttr | (motive : Lean.ExternEntry → Lean.ExternEntry → Sort u_1) →
(x x_1 : Lean.ExternEntry) →
((a b : Lean.Name) → motive (Lean.ExternEntry.adhoc a) (Lean.ExternEntry.adhoc b)) →
((a : Lean.Name) →
(a_1 : String) →
(b : Lean.Name) → (b_1 : String) → motive (Lean.ExternEntry.inline a a_1) (Lean.ExternEntry.inline b b_1)) →
((a : Lean.Name) →
(a_1 : String) →
(b : Lean.Name) →
(b_1 : String) → motive (Lean.ExternEntry.standard a a_1) (Lean.ExternEntry.standard b b_1)) →
(Unit → motive Lean.ExternEntry.opaque Lean.ExternEntry.opaque) →
((x x_2 : Lean.ExternEntry) → motive x x_2) → motive x x_1 | false |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.isLevelDefEqS.match_1.eq_2 | Lean.Meta.Sym.Pattern | ∀ (motive : Lean.Level → Lean.Level → Sort u_1)
(h_1 : (u v : Lean.Name) → motive (Lean.Level.param u) (Lean.Level.param v))
(h_2 : Unit → motive Lean.Level.zero Lean.Level.zero) (h_3 : (u v : Lean.Level) → motive u.succ v.succ)
(h_4 : (a : Lean.Level) → motive Lean.Level.zero a.succ) (h_5 : (a : Lean.Level) → motive a.succ Lean.Level.zero)
(h_6 : (v₁ v₂ : Lean.Level) → motive Lean.Level.zero (v₁.max v₂))
(h_7 : (u₁ u₂ : Lean.Level) → motive (u₁.max u₂) Lean.Level.zero)
(h_8 : (a v : Lean.Level) → motive Lean.Level.zero (a.imax v))
(h_9 : (a u : Lean.Level) → motive (a.imax u) Lean.Level.zero)
(h_10 : (u₁ u₂ v₁ v₂ : Lean.Level) → motive (u₁.max u₂) (v₁.max v₂))
(h_11 : (u₁ u₂ v₁ v₂ : Lean.Level) → motive (u₁.imax u₂) (v₁.imax v₂)) (h_12 : (x x_1 : Lean.Level) → motive x x_1),
(match Lean.Level.zero, Lean.Level.zero with
| Lean.Level.param u, Lean.Level.param v => h_1 u v
| Lean.Level.zero, Lean.Level.zero => h_2 ()
| u.succ, v.succ => h_3 u v
| Lean.Level.zero, a.succ => h_4 a
| a.succ, Lean.Level.zero => h_5 a
| Lean.Level.zero, v₁.max v₂ => h_6 v₁ v₂
| u₁.max u₂, Lean.Level.zero => h_7 u₁ u₂
| Lean.Level.zero, a.imax v => h_8 a v
| a.imax u, Lean.Level.zero => h_9 a u
| u₁.max u₂, v₁.max v₂ => h_10 u₁ u₂ v₁ v₂
| u₁.imax u₂, v₁.imax v₂ => h_11 u₁ u₂ v₁ v₂
| x, x_1 => h_12 x x_1) =
h_2 () | true |
Monoid.CoprodI.Word.cons._proof_2 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] {i : ι} (m : M i) (w : Monoid.CoprodI.Word M),
m ≠ 1 → ∀ l ∈ ⟨i, m⟩ :: w.toList, l.snd ≠ 1 | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.