name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
FBinopElab.instInhabitedSRec | Mathlib.Tactic.FBinop | Inhabited FBinopElab.SRec | null | true |
CategoryTheory.Meq.congr_apply | Mathlib.CategoryTheory.Sites.ConcreteSheafification | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {D : Type w}
[inst_1 : CategoryTheory.Category.{w', w} D] {FD : D → D → Type u_1} {CD : D → Type t}
[inst_2 : (X Y : D) → FunLike (FD X Y) (CD X) (CD Y)] [inst_3 : CategoryTheory.ConcreteCategory D FD] {X : C}
{P ... | null | true |
HomologicalComplex.instIsEquivalenceOppositeSymmOpFunctor | Mathlib.Algebra.Homology.Opposite | ∀ {ι : Type u_1} (V : Type u_2) [inst : CategoryTheory.Category.{v_1, u_2} V] (c : ComplexShape ι)
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V], (HomologicalComplex.opFunctor V c).IsEquivalence | null | true |
_private.Mathlib.Data.EReal.Operations.0.Mathlib.Meta.Positivity.evalERealAdd._proof_2 | Mathlib.Data.EReal.Operations | ∀ (α : Q(Type)) (pα : Q(PartialOrder «$α»)) (__defeqres : PLift («$pα» =Q instPartialOrderEReal)),
«$pα» =Q instPartialOrderEReal | null | false |
CategoryTheory.Limits.FormalCoproduct.cechFunctor | Mathlib.CategoryTheory.Limits.FormalCoproducts.Cech | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasFiniteProducts C] →
CategoryTheory.Functor (CategoryTheory.Limits.FormalCoproduct C)
(CategoryTheory.SimplicialObject (CategoryTheory.Limits.FormalCoproduct C)) | The functor `FormalCoproduct C ⥤ SimplicialObject (FormalCoproduct C)`
which sends a formal coproduct to its Cech object. | true |
Std.Tactic.BVDecide.BVExpr.WithCache.ctorIdx | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | {α : Type u} → {aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit} → Std.Tactic.BVDecide.BVExpr.WithCache α aig → ℕ | null | false |
Mathlib.Tactic.Conv.Path.brecOn | Mathlib.Tactic.Widget.Conv | {motive : Mathlib.Tactic.Conv.Path → Sort u} →
(t : Mathlib.Tactic.Conv.Path) →
((t : Mathlib.Tactic.Conv.Path) → Mathlib.Tactic.Conv.Path.below t → motive t) → motive t | null | false |
PrincipalSeg.ofElement_toFun | Mathlib.Order.InitialSeg | ∀ {α : Type u_4} (r : α → α → Prop) (a : α) (self : { x // r x a }), (PrincipalSeg.ofElement r a).toFun self = ↑self | null | true |
Std.ExtDHashMap.get_union_of_not_mem_left | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{k : α} (not_mem : k ∉ m₁) {h' : k ∈ m₁ ∪ m₂}, (m₁ ∪ m₂).get k h' = m₂.get k ⋯ | null | true |
Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof.core | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Lean.Expr →
Lean.Expr →
Lean.Meta.Grind.Arith.Linear.LinExpr →
Lean.Meta.Grind.Arith.Linear.LinExpr → Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof | null | true |
Equiv.Perm.Basis.rec | Mathlib.GroupTheory.Perm.Centralizer | {α : Type u_1} →
[inst : DecidableEq α] →
[inst_1 : Fintype α] →
{g : Equiv.Perm α} →
{motive : g.Basis → Sort u} →
((toFun : ↥g.cycleFactorsFinset → α) →
(mem_support_self' : ∀ (c : ↥g.cycleFactorsFinset), toFun c ∈ (↑c).support) →
motive { toFun := toFun, me... | null | false |
CategoryTheory.Bicategory.Adjunction.mk.injEq | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {a b : B} {f : a ⟶ b} {g : b ⟶ a}
(unit : CategoryTheory.CategoryStruct.id a ⟶ CategoryTheory.CategoryStruct.comp f g)
(counit : CategoryTheory.CategoryStruct.comp g f ⟶ CategoryTheory.CategoryStruct.id b)
(left_triangle :
autoParam
(CategoryTheory.Bi... | null | true |
Mathlib.Tactic.ITauto.Proof.em | Mathlib.Tactic.ITauto | Bool → Lean.Name → Mathlib.Tactic.ITauto.Proof | * `classical = false`: `(p: Decidable A) ⊢ A ∨ ¬A`
* `classical = true`: `(p: Prop) ⊢ p ∨ ¬p`
| true |
Nat.dfold_add._proof_16 | Init.Data.Nat.Fold | ∀ {n m : ℕ}, ∀ i ≤ n, i ≤ n + m | null | false |
Lean.Grind.CommRing.Mon.revlexFuel.induct_unfolding | Init.Grind.Ring.CommSolver | ∀ (motive : ℕ → Lean.Grind.CommRing.Mon → Lean.Grind.CommRing.Mon → Ordering → Prop),
(∀ (m₁ m₂ : Lean.Grind.CommRing.Mon), motive 0 m₁ m₂ (m₁.revlexWF m₂)) →
(∀ (fuel : ℕ), motive fuel.succ Lean.Grind.CommRing.Mon.unit Lean.Grind.CommRing.Mon.unit Ordering.eq) →
(∀ (fuel : ℕ) (p : Lean.Grind.CommRing.Power... | null | true |
Finset.isPWO_sup | Mathlib.Order.WellFoundedSet | ∀ {ι : Type u_1} {α : Type u_2} [inst : Preorder α] (s : Finset ι) {f : ι → Set α},
(s.sup f).IsPWO ↔ ∀ i ∈ s, (f i).IsPWO | null | true |
_private.Std.Data.Iterators.Lemmas.Producers.Repeat.0.Nat.repeat.match_1.splitter | Std.Data.Iterators.Lemmas.Producers.Repeat | {α : Type u_2} →
(motive : ℕ → α → Sort u_1) →
(x : ℕ) → (x_1 : α) → ((a : α) → motive 0 a) → ((n : ℕ) → (a : α) → motive n.succ a) → motive x x_1 | null | true |
Lean.NameMapExtension.find? | Batteries.Lean.NameMapAttribute | {α : Type} → Lean.NameMapExtension α → Lean.Environment → Lean.Name → Option α | Look up a value in the given extension in the environment. | true |
Ideal.span_range_eq_span_range_support | Mathlib.RingTheory.Ideal.Span | ∀ {α : Type u} [inst : Semiring α] {ι : Type u_1} (x : ι → α),
Ideal.span (Set.range x) = Ideal.span (Set.range fun i => x ↑i) | null | true |
MulActionHomClass.eq_1 | Mathlib.GroupTheory.GroupAction.Hom | ∀ (F : Type u_8) (M : Type u_9) (X : Type u_10) (Y : Type u_11) [inst : SMul M X] [inst_1 : SMul M Y]
[inst_2 : FunLike F X Y], MulActionHomClass F M X Y = MulActionSemiHomClass F id X Y | null | true |
Std.DHashMap.Raw.Equiv.constInsertMany_list | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α],
m₁.WF →
m₂.WF →
∀ (l : List (α × β)),
m₁.Equiv m₂ → (Std.DHashMap.Raw.Const.insertMany m₁ l).Equiv (Std.DHashMap.Raw.Const.insertMany m₂ l) | null | true |
Std.Iter.foldM_filterM | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β δ : Type w} {n : Type w → Type w''} {o : Type w → Type w'''} [inst : Std.Iterator α Id β]
[Std.Iterators.Finite α Id] [inst_2 : Monad n] [inst_3 : MonadAttach n] [LawfulMonad n] [WeaklyLawfulMonadAttach n]
[inst_6 : Monad o] [LawfulMonad o] [inst_8 : Std.IteratorLoop α Id n] [inst_9 : Std.IteratorLoop α Id o... | null | true |
CategoryTheory.Functor.isoWhiskerRight_left_assoc | Mathlib.CategoryTheory.Whiskering | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] {B : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} B] (F : CategoryTheory.Functor B C) {G H : CategoryTheory.Functor C D}
(α : G... | null | true |
HomologicalComplex.homologicalComplexToDGO | Mathlib.Algebra.Homology.DifferentialObject | {β : Type u_1} →
[inst : AddCommGroup β] →
(b : β) →
(V : Type u_2) →
[inst_1 : CategoryTheory.Category.{v_1, u_2} V] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms V] →
CategoryTheory.Functor (HomologicalComplex V (ComplexShape.up' b))
(CategoryTheory.Differe... | The functor from homological complexes to differential graded objects.
| true |
Lean.Lsp.SymbolInformation.containerName? | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SymbolInformation → Option String | null | true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunctionRecurrence._unary._proof_5 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ (pat : ByteArray) (stackPos : ℕ) (hst : stackPos < pat.size) (guess : ℕ) (hg : guess < stackPos)
(this : String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction✝ pat (guess - 1) ⋯ < guess),
String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction✝ pat (guess - 1) ⋯ < stackPos | null | false |
Fin.insertNthEquiv_last | Mathlib.Data.Fin.Tuple.Basic | ∀ (n : ℕ) (α : Type u_3), Fin.insertNthEquiv (fun x => α) (Fin.last n) = Fin.snocEquiv fun x => α | Note this lemma can only be written about non-dependent tuples as `insertNth (last n) = snoc` is
not a definitional equality. | true |
Int.inductionOn'_add_one | Mathlib.Data.Int.Init | ∀ {motive : ℤ → Sort u_1} {z b : ℤ} {zero : motive b} {succ : (k : ℤ) → b ≤ k → motive k → motive (k + 1)}
{pred : (k : ℤ) → k ≤ b → motive k → motive (k - 1)} (hz : b ≤ z),
Int.inductionOn' (z + 1) b zero succ pred = succ z hz (Int.inductionOn' z b zero succ pred) | null | true |
RatFunc.CompletionAtInfty.instValuedWithZeroMultiplicativeInt._proof_10 | Mathlib.FieldTheory.RatFunc.Valuation | ∀ (F : Type u_1) [inst : Field F] [inst_1 : DecidableEq (RatFunc F)] (x : RatFunc.CompletionAtInfty F),
nhds x = Filter.comap (Prod.mk x) (RatFunc.CompletionAtInfty.instValuedWithZeroMultiplicativeInt._aux_6 F) | null | false |
ProbabilityTheory.Kernel.integral_deterministic' | Mathlib.Probability.Kernel.Integral | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {E : Type u_3}
[inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : β → E} {a : α} [CompleteSpace E] {g : α → β}
(hg : Measurable g),
MeasureTheory.StronglyMeasurable f → ∫ (x : β), f x ∂(ProbabilityTheory.Kernel.determinis... | null | true |
CategoryTheory.ComonObj.comul | Mathlib.CategoryTheory.Monoidal.Comon_ | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} →
{X : C} → [self : CategoryTheory.ComonObj X] → X ⟶ CategoryTheory.MonoidalCategoryStruct.tensorObj X X | The comultiplication morphism of a comonoid object. | true |
CategoryTheory.Limits.MonoFactorisation.e | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} → {f : X ⟶ Y} → (self : CategoryTheory.Limits.MonoFactorisation f) → X ⟶ self.I | A factorisation of a morphism `f = e ≫ m`, with `m` monic. | true |
Mathlib.Meta.FunProp.DecompositionResult.failed.elim | Mathlib.Tactic.FunProp.FunctionData | {motive : Mathlib.Meta.FunProp.DecompositionResult → Sort u} →
(t : Mathlib.Meta.FunProp.DecompositionResult) →
t.ctorIdx = 2 → motive Mathlib.Meta.FunProp.DecompositionResult.failed → motive t | null | false |
List.min_singleton | Init.Data.List.MinMax | ∀ {α : Type u_1} [inst : Min α] {x : α}, [x].min ⋯ = x | null | true |
Multiset.zero_product | Mathlib.Data.Multiset.Bind | ∀ {α : Type u_1} {β : Type v} (t : Multiset β), 0 ×ˢ t = 0 | null | true |
PointedCone.mem_closure | Mathlib.Analysis.Convex.Cone.Closure | ∀ {𝕜 : Type u_1} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : IsOrderedRing 𝕜] {E : Type u_2}
[inst_3 : AddCommMonoid E] [inst_4 : TopologicalSpace E] [inst_5 : ContinuousAdd E] [inst_6 : Module 𝕜 E]
[inst_7 : ContinuousConstSMul 𝕜 E] {K : PointedCone 𝕜 E} {a : E}, a ∈ K.closure ↔ a ∈ closure ↑K | null | true |
ChevalleyThm.MvPolynomialC.degBound_casesOn_succ._mutual | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | ∀ (k₀ k : ℕ) (D : ℕ → ℕ) (x : ℕ ⊕' ℕ),
PSum.casesOn x
(fun _x =>
ChevalleyThm.MvPolynomialC.degBound k₀ (fun t => Nat.casesOn t k D) (_x + 1) =
(k₀ * k) ^ (k₀ * k) * ChevalleyThm.MvPolynomialC.degBound (k₀ * k) ((k₀ * k) ^ (k₀ * k) • D) _x)
fun _x =>
ChevalleyThm.MvPolynomialC.numBound k₀ (f... | null | false |
Continuous.fourier_inversion | Mathlib.Analysis.Fourier.Inversion | ∀ {V : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
[inst_2 : MeasurableSpace V] [inst_3 : BorelSpace V] [inst_4 : FiniteDimensional ℝ V] [inst_5 : NormedAddCommGroup E]
[inst_6 : NormedSpace ℂ E] {f : V → E} [CompleteSpace E],
Continuous f →
MeasureTheory.Integrable... | **Alias** of `Continuous.fourierInv_fourier_eq`.
---
**Fourier inversion formula**: If a function `f` on a finite-dimensional real inner product
space is continuous, integrable, and its Fourier transform `𝓕 f` is also integrable,
then `𝓕⁻ (𝓕 f) = f`. | true |
Directed.le_sequence | Mathlib.Logic.Encodable.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Encodable α] [inst_1 : Inhabited α] [inst_2 : Preorder β] {f : α → β}
(hf : Directed (fun x1 x2 => x1 ≤ x2) f) (a : α), f a ≤ f (Directed.sequence f hf (Encodable.encode a + 1)) | null | true |
List.tailsTR.go.eq_def | Batteries.Data.List.Basic | ∀ {α : Type u_1} (l : List α) (acc : Array (List α)),
List.tailsTR.go l acc =
match l with
| [] => acc.toListAppend [[]]
| head :: xs => List.tailsTR.go xs (acc.push l) | null | true |
_private.Mathlib.Data.Finsupp.Indicator.0.Finsupp.indicator_indicator._proof_1_2 | Mathlib.Data.Finsupp.Indicator | ∀ {ι : Type u_1} {α : Type u_2} [inst : Zero α] (s : Finset ι) {t : Finset ι} (f : (i : ι) → i ∈ s → α)
[inst_1 : DecidableEq ι],
(Finsupp.indicator t fun i x => (Finsupp.indicator s f) i) = Finsupp.indicator (s ∩ t) fun i hi => f i ⋯ | null | false |
BialgCat.mk | Mathlib.Algebra.Category.BialgCat.Basic | {R : Type u} →
[inst : CommRing R] →
(carrier : Type v) → [instRing : Ring carrier] → [instBialgebra : Bialgebra R carrier] → BialgCat R | null | true |
Std.TreeSet.Raw.le_maxD_of_contains | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, t.contains k = true → ∀ {fallback : α}, (cmp k (t.maxD fallback)).isLE = true | null | true |
Prod.instBornology._proof_1 | Mathlib.Topology.Bornology.Constructions | ∀ {α : Type u_1} {β : Type u_2} [inst : Bornology α] [inst_1 : Bornology β],
(Bornology.cobounded α).coprod (Bornology.cobounded β) ≤ Filter.cofinite | null | false |
AffineSubspace.SOppSide.trans_wSameSide | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Field R] [inst_1 : LinearOrder R]
[inst_2 : IsStrictOrderedRing R] [inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P]
{s : AffineSubspace R P} {x y z : P}, s.SOppSide x y → s.WSameSide y z → s.WOppSide x z | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Removal.0.Mathlib.Meta.Positivity.evalTriangleRemovalBound.match_4 | Mathlib.Combinatorics.SimpleGraph.Triangle.Removal | {u : Lean.Level} →
{α : Q(Type u)} →
(motive : Option Q(PartialOrder «$α») → Sort u_1) →
(pα? : Option Q(PartialOrder «$α»)) →
(Unit → motive none) → ((val : Q(PartialOrder «$α»)) → motive (some val)) → motive pα? | null | false |
SupBotHom.dual_comp | Mathlib.Order.Hom.BoundedLattice | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Max α] [inst_1 : Bot α] [inst_2 : Max β] [inst_3 : Bot β]
[inst_4 : Max γ] [inst_5 : Bot γ] (g : SupBotHom β γ) (f : SupBotHom α β),
SupBotHom.dual (g.comp f) = (SupBotHom.dual g).comp (SupBotHom.dual f) | null | true |
Nat.mem_divisors_self | Mathlib.NumberTheory.Divisors | ∀ (n : ℕ), n ≠ 0 → n ∈ n.divisors | null | true |
UInt16.le_refl._simp_1 | Init.Data.UInt.Lemmas | ∀ (a : UInt16), (a ≤ a) = True | null | false |
AlexDisc.recOn | Mathlib.Topology.Order.Category.AlexDisc | {motive : AlexDisc → Sort u} →
(t : AlexDisc) →
((toTopCat : TopCat) →
[is_alexandrovDiscrete : AlexandrovDiscrete ↑toTopCat] →
motive { toTopCat := toTopCat, is_alexandrovDiscrete := is_alexandrovDiscrete }) →
motive t | null | false |
CochainComplex.mappingCone.δ_descCochain._proof_2 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ {n : ℤ} (n' : ℤ), n + 1 = n' → 1 + n = n' | null | false |
_private.Mathlib.Data.Fintype.Prod.0.Finset.product_eq_univ._simp_1_1 | Mathlib.Data.Fintype.Prod | ∀ {α : Type u_1} [inst : Fintype α] {s : Finset α}, (s = Finset.univ) = ∀ (x : α), x ∈ s | null | false |
PowerSeries.exp_pow_eq_rescale_exp | Mathlib.RingTheory.PowerSeries.Exp | ∀ {A : Type u_4} [inst : CommRing A] [inst_1 : Algebra ℚ A] (k : ℕ),
PowerSeries.exp A ^ k = (PowerSeries.rescale ↑k) (PowerSeries.exp A) | Shows that $(e^{X})^k = e^{kX}$. | true |
ContinuousMulEquiv.eq_symm_comp | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {M : Type u_1} {N : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace N] [inst_2 : Mul M]
[inst_3 : Mul N] {α : Type u_3} (e : M ≃ₜ* N) (f : α → M) (g : α → N), f = ⇑e.symm ∘ g ↔ ⇑e ∘ f = g | null | true |
AlgebraicGeometry.Scheme.Cover.Over | Mathlib.AlgebraicGeometry.Cover.Over | (S : AlgebraicGeometry.Scheme) →
{P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
[P.IsStableUnderBaseChange] →
[AlgebraicGeometry.Scheme.IsJointlySurjectivePreserving P] →
{X : AlgebraicGeometry.Scheme} →
[X.Over S] → AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Schem... | A `P`-cover of a scheme `X` over `S` is a cover, where the components are over `S` and the
component maps commute with the structure morphisms. | true |
QuotientGroup.preimage_image_mk | Mathlib.GroupTheory.Coset.Defs | ∀ {α : Type u_1} [inst : Group α] (N : Subgroup α) (s : Set α),
QuotientGroup.mk ⁻¹' QuotientGroup.mk '' s = ⋃ x, (fun x_1 => x_1 * ↑x) ⁻¹' s | null | true |
ValuativeRel.ValueGroupWithZero.exact | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : ValuativeRel R] {x y : R} {t s : ↥(ValuativeRel.posSubmonoid R)},
ValuativeRel.ValueGroupWithZero.mk x t = ValuativeRel.ValueGroupWithZero.mk y s → x * ↑s ≤ᵥ y * ↑t ∧ y * ↑t ≤ᵥ x * ↑s | null | true |
Ordering.swap.eq_3 | Std.Data.DTreeMap.Internal.Model | Ordering.gt.swap = Ordering.lt | null | true |
ZFSet.singleton_inj._simp_1 | Mathlib.SetTheory.ZFC.Basic | ∀ {x y : ZFSet.{u_1}}, ({x} = {y}) = (x = y) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.