tasksource/leandojo huggingface dataset:
Theorem: IsLocalization.nonZeroDivisors_le_comap
File: Mathlib/RingTheory/Localization/Basic.lean

tactic: rintro a ha b (e : b * algebraMap R S a = 0)
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type ?u.2732028
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
⊢ nonZeroDivisors R ≤ Submonoid.comap (algebraMap R S) (nonZeroDivisors S)

tactic: obtain ⟨x, s, rfl⟩ := mk'_surjective M b
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type ?u.2732028
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
a : R
ha : a ∈ nonZeroDivisors R
b : S
e : b * ↑(algebraMap R S) a = 0
⊢ b = 0

tactic: rw [← @mk'_one R _ M, ← mk'_mul, ← (algebraMap R S).map_zero, ← @mk'_one R _ M,
  IsLocalization.eq] at e
state_before: case intro.intro
R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type ?u.2732028
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
a : R
ha : a ∈ nonZeroDivisors R
x : R
s : { x // x ∈ M }
e : mk' S x s * ↑(algebraMap R S) a = 0
⊢ mk' S x s = 0

tactic: obtain ⟨c, e⟩ := e
state_before: case intro.intro
R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type ?u.2732028
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
a : R
ha : a ∈ nonZeroDivisors R
x : R
s : { x // x ∈ M }
e : ∃ c, ↑c * (↑1 * (x * a)) = ↑c * (↑(s * 1) * 0)
⊢ mk' S x s = 0

tactic: rw [mul_zero, mul_zero, Submonoid.coe_one, one_mul, ← mul_assoc] at e
state_before: case intro.intro.intro
R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type ?u.2732028
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
a : R
ha : a ∈ nonZeroDivisors R
x : R
s c : { x // x ∈ M }
e : ↑c * (↑1 * (x * a)) = ↑c * (↑(s * 1) * 0)
⊢ mk' S x s = 0

tactic: rw [mk'_eq_zero_iff]
state_before: case intro.intro.intro
R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type ?u.2732028
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
a : R
ha : a ∈ nonZeroDivisors R
x : R
s c : { x // x ∈ M }
e : ↑c * x * a = 0
⊢ mk' S x s = 0

tactic: exact ⟨c, ha _ e⟩
state_before: case intro.intro.intro
R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type ?u.2732028
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
a : R
ha : a ∈ nonZeroDivisors R
x : R
s c : { x // x ∈ M }
e : ↑c * x * a = 0
⊢ ∃ m, ↑m * x = 0
Theorem: CategoryTheory.CosimplicialObject.δ_comp_σ_succ
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: dsimp [δ, σ]
state_before: C : Type u
inst✝ : Category C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ δ X (Fin.succ i) ≫ σ X i = 𝟙 (X.obj [n])

tactic: simp only [← X.map_comp, SimplexCategory.δ_comp_σ_succ, X.map_id]
state_before: C : Type u
inst✝ : Category C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ X.map (SimplexCategory.δ (Fin.succ i)) ≫ X.map (SimplexCategory.σ i) = 𝟙 (X.obj [n])
Theorem: FreeMagma.length_toFreeSemigroup
File: Mathlib/Algebra/Free.lean

tactic: rw [map_mul, FreeSemigroup.length_mul, hx, hy]
state_before: α : Type u
β : Type v
x✝ x y : FreeMagma α
hx : FreeSemigroup.length (↑toFreeSemigroup x) = length x
hy : FreeSemigroup.length (↑toFreeSemigroup y) = length y
⊢ FreeSemigroup.length (↑toFreeSemigroup (x * y)) = length (x * y)

tactic: rfl
state_before: α : Type u
β : Type v
x✝ x y : FreeMagma α
hx : FreeSemigroup.length (↑toFreeSemigroup x) = length x
hy : FreeSemigroup.length (↑toFreeSemigroup y) = length y
⊢ length x + length y = length (x * y)
Theorem: Measurable.nnreal_tsum
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean

tactic: simp_rw [NNReal.tsum_eq_toNNReal_tsum]
state_before: α : Type u_2
β : Type ?u.2930312
γ : Type ?u.2930315
γ₂ : Type ?u.2930318
δ : Type ?u.2930321
ι✝ : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
ι : Type u_1
inst✝ : Countable ι
f : ι → α → ℝ≥0
h : ∀ (i : ι), Measurable (f i)
⊢ Measurable fun x => ∑' (i : ι), f i x

tactic: exact (Measurable.ennreal_tsum fun i => (h i).coe_nnreal_ennreal).ennreal_toNNReal
state_before: α : Type u_2
β : Type ?u.2930312
γ : Type ?u.2930315
γ₂ : Type ?u.2930318
δ : Type ?u.2930321
ι✝ : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
ι : Type u_1
inst✝ : Countable ι
f : ι → α → ℝ≥0
h : ∀ (i : ι), Measurable (f i)
⊢ Measurable fun x => ENNReal.toNNReal (∑' (b : ι), ↑(f b x))
Theorem: CategoryTheory.Limits.spanExt_hom_app_zero
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: dsimp [spanExt]
state_before: C : Type u
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (spanExt iX iY iZ wf wg).hom.app WalkingSpan.zero = iX.hom
Theorem: apply_dite₂
File: Mathlib/Logic/Basic.lean

tactic: by_cases h : P <;> simp [h]
state_before: α : Sort u_2
β : Sort u_3
σ : α → Sort ?u.38655
f✝ : α → β
P✝ Q : Prop
inst✝² : Decidable P✝
inst✝¹ : Decidable Q
a✝ b✝ c✝ : α
A : P✝ → α
B : ¬P✝ → α
γ : Sort u_1
f : α → β → γ
P : Prop
inst✝ : Decidable P
a : P → α
b : ¬P → α
c : P → β
d : ¬P → β
⊢ f (dite P a b) (dite P c d) = if h : P then f (a h) (c h) else f (b h) (d h)
Theorem: CategoryTheory.Limits.Fork.hom_comp_ι
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

tactic: cases s
state_before: C : Type u
inst✝ : Category C
X Y : C
f✝ g : X ⟶ Y
s t : Fork f✝ g
f : s ⟶ t
⊢ f.Hom ≫ ι t = ι s

tactic: cases t
state_before: case mk
C : Type u
inst✝ : Category C
X Y : C
f✝ g : X ⟶ Y
t : Fork f✝ g
pt✝ : C
π✝ : (Functor.const WalkingParallelPair).obj pt✝ ⟶ parallelPair f✝ g
f : { pt := pt✝, π := π✝ } ⟶ t
⊢ f.Hom ≫ ι t = ι { pt := pt✝, π := π✝ }

tactic: cases f
state_before: case mk.mk
C : Type u
inst✝ : Category C
X Y : C
f✝ g : X ⟶ Y
pt✝¹ : C
π✝¹ : (Functor.const WalkingParallelPair).obj pt✝¹ ⟶ parallelPair f✝ g
pt✝ : C
π✝ : (Functor.const WalkingParallelPair).obj pt✝ ⟶ parallelPair f✝ g
f : { pt := pt✝¹, π := π✝¹ } ⟶ { pt := pt✝, π := π✝ }
⊢ f.Hom ≫ ι { pt := pt✝, π := π✝ } = ι { pt := pt✝¹, π := π✝¹ }

tactic: aesop
state_before: case mk.mk.mk
C : Type u
inst✝ : Category C
X Y : C
f g : X ⟶ Y
pt✝¹ : C
π✝¹ : (Functor.const WalkingParallelPair).obj pt✝¹ ⟶ parallelPair f g
pt✝ : C
π✝ : (Functor.const WalkingParallelPair).obj pt✝ ⟶ parallelPair f g
Hom✝ : { pt := pt✝¹, π := π✝¹ }.pt ⟶ { pt := pt✝, π := π✝ }.pt
w✝ : ∀ (j : WalkingParallelPair), Hom✝ ≫ { pt := pt✝, π := π✝ }.π.app j = { pt := pt✝¹, π := π✝¹ }.π.app j
⊢ (ConeMorphism.mk Hom✝).Hom ≫ ι { pt := pt✝, π := π✝ } = ι { pt := pt✝¹, π := π✝¹ }
Theorem: CategoryTheory.Iso.comp_inv_eq
File: Mathlib/CategoryTheory/Iso.lean

tactic: simp [H.symm]
state_before: C : Type u
inst✝ : Category C
X Y Z : C
α : X ≅ Y
f : Z ⟶ Y
g : Z ⟶ X
H : f ≫ α.inv = g
⊢ f = g ≫ α.hom

tactic: simp [H]
state_before: C : Type u
inst✝ : Category C
X Y Z : C
α : X ≅ Y
f : Z ⟶ Y
g : Z ⟶ X
H : f = g ≫ α.hom
⊢ f ≫ α.inv = g
Theorem: PolyEquivTensor.right_inv
File: Mathlib/RingTheory/PolynomialAlgebra.lean

tactic: refine Polynomial.induction_on' x ?_ ?_
state_before: R : Type u_2
A : Type u_1
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : A[X]
⊢ ↑(toFunAlgHom R A) (invFun R A x) = x

tactic: intro p q hp hq
state_before: case refine_1
R : Type u_2
A : Type u_1
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : A[X]
⊢ ∀ (p q : A[X]),
    ↑(toFunAlgHom R A) (invFun R A p) = p →
      ↑(toFunAlgHom R A) (invFun R A q) = q → ↑(toFunAlgHom R A) (invFun R A (p + q)) = p + q

tactic: simp only [invFun_add, AlgHom.map_add, hp, hq]
state_before: case refine_1
R : Type u_2
A : Type u_1
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
x p q : A[X]
hp : ↑(toFunAlgHom R A) (invFun R A p) = p
hq : ↑(toFunAlgHom R A) (invFun R A q) = q
⊢ ↑(toFunAlgHom R A) (invFun R A (p + q)) = p + q

tactic: intro n a
state_before: case refine_2
R : Type u_2
A : Type u_1
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : A[X]
⊢ ∀ (n : ℕ) (a : A), ↑(toFunAlgHom R A) (invFun R A (↑(monomial n) a)) = ↑(monomial n) a

tactic: rw [invFun_monomial, Algebra.TensorProduct.includeLeft_apply, Algebra.TensorProduct.tmul_pow,
    one_pow, Algebra.TensorProduct.tmul_mul_tmul, mul_one, one_mul, toFunAlgHom_apply_tmul,
    X_pow_eq_monomial, sum_monomial_index] <;>
  simp
state_before: case refine_2
R : Type u_2
A : Type u_1
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : A[X]
n : ℕ
a : A
⊢ ↑(toFunAlgHom R A) (invFun R A (↑(monomial n) a)) = ↑(monomial n) a
Theorem: Filter.Tendsto.prod_map
File: Mathlib/Order/Filter/Prod.lean

tactic: erw [Tendsto, ← prod_map_map_eq]
state_before: α : Type u_2
β : Type u_3
γ : Type u_4
δ✝ : Type ?u.29553
ι : Sort ?u.29556
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
δ : Type u_1
f : α → γ
g : β → δ
a : Filter α
b : Filter β
c : Filter γ
d : Filter δ
hf : Tendsto f a c
hg : Tendsto g b d
⊢ Tendsto (Prod.map f g) (a ×ˢ b) (c ×ˢ d)

tactic: exact Filter.prod_mono hf hg
state_before: α : Type u_2
β : Type u_3
γ : Type u_4
δ✝ : Type ?u.29553
ι : Sort ?u.29556
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
δ : Type u_1
f : α → γ
g : β → δ
a : Filter α
b : Filter β
c : Filter γ
d : Filter δ
hf : Tendsto f a c
hg : Tendsto g b d
⊢ map f a ×ˢ map g b ≤ c ×ˢ d
Theorem: Multiset.dvd_sum
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: rw [sum_cons]
state_before: ι : Type ?u.115200
α : Type u_1
β : Type ?u.115206
γ : Type ?u.115209
inst✝ : Semiring α
a : α
s✝ : Multiset α
x : α
s : Multiset α
ih : (∀ (x : α), x ∈ s → a ∣ x) → a ∣ sum s
h : ∀ (x_1 : α), x_1 ∈ x ::ₘ s → a ∣ x_1
⊢ a ∣ sum (x ::ₘ s)

tactic: exact dvd_add (h _ (mem_cons_self _ _)) (ih fun y hy => h _ <| mem_cons.2 <| Or.inr hy)
state_before: ι : Type ?u.115200
α : Type u_1
β : Type ?u.115206
γ : Type ?u.115209
inst✝ : Semiring α
a : α
s✝ : Multiset α
x : α
s : Multiset α
ih : (∀ (x : α), x ∈ s → a ∣ x) → a ∣ sum s
h : ∀ (x_1 : α), x_1 ∈ x ::ₘ s → a ∣ x_1
⊢ a ∣ x + sum s
Theorem: Basis.det_isEmpty
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: ext v
state_before: R : Type u_2
inst✝⁷ : CommRing R
M : Type u_3
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
M' : Type ?u.2538346
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R M'
ι : Type u_1
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
e : Basis ι R M
inst✝ : IsEmpty ι
⊢ det e = AlternatingMap.constOfIsEmpty R M ι 1

tactic: exact Matrix.det_isEmpty
state_before: case H
R : Type u_2
inst✝⁷ : CommRing R
M : Type u_3
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
M' : Type ?u.2538346
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R M'
ι : Type u_1
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
e : Basis ι R M
inst✝ : IsEmpty ι
v : ι → M
⊢ ↑(det e) v = ↑(AlternatingMap.constOfIsEmpty R M ι 1) v
Theorem: GaloisInsertion.l_iInf_of_ul_eq_self
File: Mathlib/Order/GaloisConnection.lean

tactic: simp [hf]
state_before: α : Type u
β : Type v
γ : Type w
ι✝ : Sort x
κ : ι✝ → Sort ?u.42456
a a₁ a₂ : α
b b₁ b₂ : β
l : α → β
u : β → α
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
gi : GaloisInsertion l u
ι : Sort x
f : ι → α
hf : ∀ (i : ι), u (l (f i)) = f i
⊢ l (⨅ (i : ι), f i) = l (⨅ (i : ι), u (l (f i)))
Theorem: Seminorm.ball_zero_eq_preimage_ball
File: Mathlib/Analysis/Seminorm.lean

tactic: rw [ball_zero_eq, preimage_metric_ball]
state_before: R : Type ?u.1017930
R' : Type ?u.1017933
𝕜 : Type u_2
𝕜₂ : Type ?u.1017939
𝕜₃ : Type ?u.1017942
𝕝 : Type ?u.1017945
E : Type u_1
E₂ : Type ?u.1017951
E₃ : Type ?u.1017954
F : Type ?u.1017957
G : Type ?u.1017960
ι : Type ?u.1017963
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p : Seminorm 𝕜 E
r : ℝ
⊢ ball p 0 r = ↑p ⁻¹' Metric.ball 0 r
Theorem: Finset.le_card_sdiff
File: Mathlib/Data/Finset/Card.lean

tactic: rw [sdiff_inter_self_right t s]
state_before: α : Type u_1
β : Type ?u.40449
s✝ t✝ : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
s t : Finset α
⊢ card (t \ (s ∩ t)) ≤ card (t \ s)
Theorem: Dfinsupp.comapDomain_smul
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type u_1
inst✝² : Monoid γ
inst✝¹ : (i : ι) → AddMonoid (β i)
inst✝ : (i : ι) → DistribMulAction γ (β i)
h : κ → ι
hh : Function.Injective h
r : γ
f : Π₀ (i : ι), β i
⊢ comapDomain h hh (r • f) = r • comapDomain h hh f

tactic: rw [smul_apply, comapDomain_apply, smul_apply, comapDomain_apply]
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type u_1
inst✝² : Monoid γ
inst✝¹ : (i : ι) → AddMonoid (β i)
inst✝ : (i : ι) → DistribMulAction γ (β i)
h : κ → ι
hh : Function.Injective h
r : γ
f : Π₀ (i : ι), β i
i✝ : κ
⊢ ↑(comapDomain h hh (r • f)) i✝ = ↑(r • comapDomain h hh f) i✝
Theorem: Quaternion.exp_eq
File: Mathlib/Analysis/NormedSpace/QuaternionExponential.lean

tactic: rw [← exp_of_re_eq_zero q.im q.im_re, ← coe_mul_eq_smul, ← exp_coe, ← exp_add_of_commute,
  re_add_im]
state_before: q : ℍ
⊢ exp ℝ q = exp ℝ q.re • (↑(Real.cos ‖im q‖) + (Real.sin ‖im q‖ / ‖im q‖) • im q)

tactic: exact Algebra.commutes q.re (_ : ℍ[ℝ])
state_before: q : ℍ
⊢ Commute (↑q.re) (im q)
Theorem: Orientation.finOrthonormalBasis_orientation
File: Mathlib/Analysis/InnerProductSpace/Orientation.lean

tactic: haveI := Fin.pos_iff_nonempty.1 hn
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
n : ℕ
hn : 0 < n
h : finrank ℝ E = n
x : Orientation ℝ E (Fin n)
⊢ Basis.orientation (OrthonormalBasis.toBasis (Orientation.finOrthonormalBasis hn h x)) = x

tactic: haveI := finiteDimensional_of_finrank (h.symm ▸ hn : 0 < finrank ℝ E)
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
n : ℕ
hn : 0 < n
h : finrank ℝ E = n
x : Orientation ℝ E (Fin n)
this : Nonempty (Fin n)
⊢ Basis.orientation (OrthonormalBasis.toBasis (Orientation.finOrthonormalBasis hn h x)) = x

tactic: exact ((@stdOrthonormalBasis _ _ _ _ _ this).reindex <|
  finCongr h).orientation_adjustToOrientation x
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
n : ℕ
hn : 0 < n
h : finrank ℝ E = n
x : Orientation ℝ E (Fin n)
this✝ : Nonempty (Fin n)
this : FiniteDimensional ℝ E
⊢ Basis.orientation (OrthonormalBasis.toBasis (Orientation.finOrthonormalBasis hn h x)) = x
Theorem: aemeasurable_biInf
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean

tactic: haveI : Encodable s := hs.toEncodable
state_before: α : Type u_3
β : Type ?u.1581955
γ : Type ?u.1581958
γ₂ : Type ?u.1581961
δ : Type u_2
ι✝ : Sort y
s✝ t u : Set α
inst✝¹² : TopologicalSpace α
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : BorelSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : BorelSpace β
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : BorelSpace γ
inst✝³ : MeasurableSpace δ
inst✝² : CompleteLinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
ι : Type u_1
μ : MeasureTheory.Measure δ
s : Set ι
f : ι → δ → α
hs : Set.Countable s
hf : ∀ (i : ι), AEMeasurable (f i)
⊢ AEMeasurable fun b => ⨅ (i : ι) (_ : i ∈ s), f i b

tactic: simp only [iInf_subtype']
state_before: α : Type u_3
β : Type ?u.1581955
γ : Type ?u.1581958
γ₂ : Type ?u.1581961
δ : Type u_2
ι✝ : Sort y
s✝ t u : Set α
inst✝¹² : TopologicalSpace α
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : BorelSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : BorelSpace β
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : BorelSpace γ
inst✝³ : MeasurableSpace δ
inst✝² : CompleteLinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
ι : Type u_1
μ : MeasureTheory.Measure δ
s : Set ι
f : ι → δ → α
hs : Set.Countable s
hf : ∀ (i : ι), AEMeasurable (f i)
this : Encodable ↑s
⊢ AEMeasurable fun b => ⨅ (i : ι) (_ : i ∈ s), f i b

tactic: exact aemeasurable_iInf fun i => hf i
state_before: α : Type u_3
β : Type ?u.1581955
γ : Type ?u.1581958
γ₂ : Type ?u.1581961
δ : Type u_2
ι✝ : Sort y
s✝ t u : Set α
inst✝¹² : TopologicalSpace α
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : BorelSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : BorelSpace β
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : BorelSpace γ
inst✝³ : MeasurableSpace δ
inst✝² : CompleteLinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
ι : Type u_1
μ : MeasureTheory.Measure δ
s : Set ι
f : ι → δ → α
hs : Set.Countable s
hf : ∀ (i : ι), AEMeasurable (f i)
this : Encodable ↑s
⊢ AEMeasurable fun b => ⨅ (x : { i // i ∈ s }), f (↑x) b
Theorem: Set.forall_subset_range_iff
File: Mathlib/Data/Set/Image.lean

tactic: rw [← forall_range_iff, range_image]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.76965
ι : Sort ?u.76968
ι' : Sort ?u.76971
f✝ : ι → α
s t : Set α
f : α → β
p : Set β → Prop
⊢ (∀ (s : Set β), s ⊆ range f → p s) ↔ ∀ (s : Set α), p (f '' s)

tactic: rfl
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.76965
ι : Sort ?u.76968
ι' : Sort ?u.76971
f✝ : ι → α
s t : Set α
f : α → β
p : Set β → Prop
⊢ (∀ (s : Set β), s ⊆ range f → p s) ↔ ∀ (a : Set β), a ∈ 𝒫 range f → p a
Theorem: Nat.mul_mod
File: Std/Data/Nat/Lemmas.lean

tactic: conv => lhs; rw [
  ← mod_add_div a n, ← mod_add_div b n, Nat.add_mul, Nat.mul_add, Nat.mul_add,
  Nat.mul_assoc, Nat.mul_assoc, ← Nat.mul_add n, add_mul_mod_self_left,
  Nat.mul_comm _ (n * (b / n)), Nat.mul_assoc, add_mul_mod_self_left]
state_before: a b n : Nat
⊢ a * b % n = a % n * (b % n) % n
Theorem: Nat.gcd_mul_left_right
File: Std/Data/Nat/Gcd.lean

tactic: rw [gcd_comm, gcd_mul_left_left]
state_before: m n : Nat
⊢ gcd n (m * n) = n
Theorem: Multiset.monotone_filter_right
File: Mathlib/Data/Multiset/Basic.lean

tactic: simpa using h
state_before: α : Type u_1
β : Type ?u.208071
γ : Type ?u.208074
p✝ : α → Prop
inst✝² : DecidablePred p✝
s : Multiset α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∀ (b : α), p b → q b
l : List α
⊢ ∀ (a : α), decide (p a) = true → decide (q a) = true
Theorem: Multiset.dvd_gcd
File: Mathlib/Algebra/GCDMonoid/Multiset.lean

tactic: simp
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s : Multiset α
a : α
⊢ a ∣ gcd 0 ↔ ∀ (b : α), b ∈ 0 → a ∣ b

tactic: simp (config := { contextual := true }) [or_imp, forall_and, dvd_gcd_iff]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s : Multiset α
a : α
⊢ ∀ ⦃a_1 : α⦄ {s : Multiset α},
    (a ∣ gcd s ↔ ∀ (b : α), b ∈ s → a ∣ b) → (a ∣ gcd (a_1 ::ₘ s) ↔ ∀ (b : α), b ∈ a_1 ::ₘ s → a ∣ b)
Theorem: Function.Periodic.const_smul
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [smul_add, smul_inv_smul] using h (a • x)
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
f g : α → β
c c₁ c₂ x✝ : α
inst✝² : AddMonoid α
inst✝¹ : Group γ
inst✝ : DistribMulAction γ α
h : Periodic f c
a : γ
x : α
⊢ (fun x => f (a • x)) (x + a⁻¹ • c) = (fun x => f (a • x)) x
Theorem: Option.some_inj
File: Std/Data/Option/Basic.lean

tactic: simp
state_before: α : Type u_1
a b : α
⊢ some a = some b ↔ a = b
Theorem: Multiset.union_zero
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp [union_def]
state_before: α : Type u_1
β : Type ?u.170514
γ : Type ?u.170517
inst✝ : DecidableEq α
s t u : Multiset α
a b : α
⊢ s ∪ 0 = s
Theorem: PGame.Subsequent.moveRight_mk_right
File: Mathlib/SetTheory/Game/PGame.lean

tactic: pgame_wf_tac
state_before: xr : Type u_1
i : xr
xl : Type u_1
xL : xl → PGame
xR : xr → PGame
j : RightMoves (xR i)
⊢ Subsequent (PGame.moveRight (xR i) j) (mk xl xr xL xR)
Theorem: pow_lt_pow₀
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: induction' hmn with n _ ih
state_before: β : Type ?u.287678
A : Type ?u.287681
G : Type ?u.287684
M : Type u_1
R : Type ?u.287690
inst✝ : LinearOrderedCommGroupWithZero M
a : M
m n : ℕ
ha : 1 < a
hmn : m < n
⊢ a ^ m < a ^ n

tactic: exacts [pow_lt_pow_succ ha, lt_trans ih (pow_lt_pow_succ ha)]
state_before: case refl
β : Type ?u.287678
A : Type ?u.287681
G : Type ?u.287684
M : Type u_1
R : Type ?u.287690
inst✝ : LinearOrderedCommGroupWithZero M
a : M
m n : ℕ
ha : 1 < a
⊢ a ^ m < a ^ Nat.succ m

case step
β : Type ?u.287678
A : Type ?u.287681
G : Type ?u.287684
M : Type u_1
R : Type ?u.287690
inst✝ : LinearOrderedCommGroupWithZero M
a : M
m n✝ : ℕ
ha : 1 < a
n : ℕ
a✝ : Nat.le (Nat.succ m) n
ih : a ^ m < a ^ n
⊢ a ^ m < a ^ Nat.succ n
Theorem: Option.ne_none_iff_isSome
File: Std/Data/Option/Lemmas.lean

tactic: cases o <;> simp
state_before: α✝ : Type u_1
o : Option α✝
⊢ o ≠ none ↔ isSome o = true
Theorem: QuotientMap.continuous_lift_prod_right
File: Mathlib/Topology/CompactOpen.lean

tactic: have : Continuous fun p : X₀ × Y => g ((Prod.swap p).1, f (Prod.swap p).2) :=
  hg.comp continuous_swap
state_before: X₀ : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
inst✝⁴ : TopologicalSpace X₀
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : LocallyCompactSpace Y
f : X₀ → X
hf : QuotientMap f
g : Y × X → Z
hg : Continuous fun p => g (p.fst, f p.snd)
⊢ Continuous g

tactic: have : Continuous fun p : X₀ × Y => (g ∘ Prod.swap) (f p.1, p.2) := this
state_before: X₀ : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
inst✝⁴ : TopologicalSpace X₀
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : LocallyCompactSpace Y
f : X₀ → X
hf : QuotientMap f
g : Y × X → Z
hg : Continuous fun p => g (p.fst, f p.snd)
this : Continuous fun p => g ((Prod.swap p).fst, f (Prod.swap p).snd)
⊢ Continuous g

tactic: exact (hf.continuous_lift_prod_left this).comp continuous_swap
state_before: X₀ : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
inst✝⁴ : TopologicalSpace X₀
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : LocallyCompactSpace Y
f : X₀ → X
hf : QuotientMap f
g : Y × X → Z
hg : Continuous fun p => g (p.fst, f p.snd)
this✝ : Continuous fun p => g ((Prod.swap p).fst, f (Prod.swap p).snd)
this : Continuous fun p => (g ∘ Prod.swap) (f p.fst, p.snd)
⊢ Continuous g
Theorem: Nat.cast_int_covby_iff
File: Mathlib/Data/Int/SuccPred.lean

tactic: rw [Nat.covby_iff_succ_eq, Int.covby_iff_succ_eq]
state_before: a b : ℕ
⊢ ↑a ⋖ ↑b ↔ a ⋖ b

tactic: exact Int.coe_nat_inj'
state_before: a b : ℕ
⊢ ↑a + 1 = ↑b ↔ a + 1 = b
Theorem: abs_lt_iff_mul_self_lt
File: Mathlib/Algebra/Order/Ring/Abs.lean

tactic: rw [← abs_mul_abs_self, ← abs_mul_abs_self b]
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
a b c : α
⊢ abs a < abs b ↔ a * a < b * b

tactic: exact mul_self_lt_mul_self_iff (abs_nonneg a) (abs_nonneg b)
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
a b c : α
⊢ abs a < abs b ↔ abs a * abs a < abs b * abs b
Theorem: Derivation.map_coe_nat
File: Mathlib/RingTheory/Derivation/Basic.lean

tactic: rw [← nsmul_one, D.map_smul_of_tower n, map_one_eq_zero, smul_zero]
state_before: R : Type u_3
inst✝⁵ : CommSemiring R
A : Type u_2
inst✝⁴ : CommSemiring A
inst✝³ : Algebra R A
M : Type u_1
inst✝² : AddCommMonoid M
inst✝¹ : Module A M
inst✝ : Module R M
D D1 D2 : Derivation R A M
r : R
a b : A
n : ℕ
⊢ ↑D ↑n = 0
Theorem: SimpleGraph.Subgraph.edgeSet_sup
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: simp
state_before: ι : Sort ?u.107383
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
H₁ H₂ : Subgraph G
⊢ ∀ (x y : V),
    Quotient.mk (Sym2.Rel.setoid V) (x, y) ∈ edgeSet (H₁ ⊔ H₂) ↔
      Quotient.mk (Sym2.Rel.setoid V) (x, y) ∈ edgeSet H₁ ∪ edgeSet H₂