1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Real.sqrt_eq_iff_mul_self_eq_of_pos
File: Mathlib/Data/Real/Sqrt.lean

tactic: simp [sqrt_eq_cases, h.ne', h.le]
state_before: x y : ℝ
h : 0 < y
⊢ √x = y ↔ y * y = x
state_after: no goals
Theorem: AlgebraicTopology.DoldKan.Γ₀.Obj.Termwise.mapMono_δ₀'
File: Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean

tactic: unfold mapMono
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
i : Δ' ⟶ Δ
inst✝ : Mono i
hi : Isδ₀ i
⊢ mapMono K i = K.d Δ.len Δ'.len
state_after: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
i : Δ' ⟶ Δ
inst✝ : Mono i
hi : Isδ₀ i
⊢ (if h : Δ = Δ' then eqToHom ⋯ else if h : Isδ₀ i then K.d Δ.len Δ'.len else 0) = K.d Δ.len Δ'.len

tactic: suffices Δ ≠ Δ' by
  simp only [dif_neg this, dif_pos hi]
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
i : Δ' ⟶ Δ
inst✝ : Mono i
hi : Isδ₀ i
⊢ (if h : Δ = Δ' then eqToHom ⋯ else if h : Isδ₀ i then K.d Δ.len Δ'.len else 0) = K.d Δ.len Δ'.len
state_after: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
i : Δ' ⟶ Δ
inst✝ : Mono i
hi : Isδ₀ i
⊢ Δ ≠ Δ'

tactic: rintro rfl
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
i : Δ' ⟶ Δ
inst✝ : Mono i
hi : Isδ₀ i
⊢ Δ ≠ Δ'
state_after: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ'' : SimplexCategory
i : Δ ⟶ Δ
inst✝ : Mono i
hi : Isδ₀ i
⊢ False

tactic: simpa only [self_eq_add_right, Nat.one_ne_zero] using hi.1
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ'' : SimplexCategory
i : Δ ⟶ Δ
inst✝ : Mono i
hi : Isδ₀ i
⊢ False
state_after: no goals

tactic: simp only [dif_neg this, dif_pos hi]
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
i : Δ' ⟶ Δ
inst✝ : Mono i
hi : Isδ₀ i
this : Δ ≠ Δ'
⊢ (if h : Δ = Δ' then eqToHom ⋯ else if h : Isδ₀ i then K.d Δ.len Δ'.len else 0) = K.d Δ.len Δ'.len
state_after: no goals
Theorem: CircleDeg1Lift.isUnit_iff_bijective
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simp only [Equiv.ofBijective_apply_symm_apply f h, hxy]
state_before: f✝ g f : CircleDeg1Lift
h : Bijective ⇑f
x y : ℝ
hxy : x ≤ y
⊢ f ((Equiv.ofBijective (⇑f) h).symm x) ≤ f ((Equiv.ofBijective (⇑f) h).symm y)
state_after: no goals

tactic: simp only [Equiv.ofBijective_apply_symm_apply f, f.map_add_one]
state_before: f✝ g f : CircleDeg1Lift
h : Bijective ⇑f
x : ℝ
⊢ f ({ toFun := ⇑(Equiv.ofBijective (⇑f) h).symm, monotone' := ⋯ }.toFun (x + 1)) =
    f ({ toFun := ⇑(Equiv.ofBijective (⇑f) h).symm, monotone' := ⋯ }.toFun x + 1)
state_after: no goals
Theorem: Real.log_inv
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: by_cases hx : x = 0
state_before: x✝ y x : ℝ
⊢ log x⁻¹ = -log x
state_after: case pos
x✝ y x : ℝ
hx : x = 0
⊢ log x⁻¹ = -log x

case neg
x✝ y x : ℝ
hx : ¬x = 0
⊢ log x⁻¹ = -log x

tactic: rw [← exp_eq_exp, exp_log_eq_abs (inv_ne_zero hx), exp_neg, exp_log_eq_abs hx, abs_inv]
state_before: case neg
x✝ y x : ℝ
hx : ¬x = 0
⊢ log x⁻¹ = -log x
state_after: no goals

tactic: simp [hx]
state_before: case pos
x✝ y x : ℝ
hx : x = 0
⊢ log x⁻¹ = -log x
state_after: no goals
Theorem: MeasureTheory.lintegral_rpow_nnnorm_lt_top_of_snorm_lt_top
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

tactic: apply lintegral_rpow_nnnorm_lt_top_of_snorm'_lt_top
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hfp : snorm f p μ < ⊤
⊢ ∫⁻ (a : α), ↑‖f a‖₊ ^ p.toReal ∂μ < ⊤
state_after: case hq0_lt
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hfp : snorm f p μ < ⊤
⊢ 0 < p.toReal

case hfq
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hfp : snorm f p μ < ⊤
⊢ snorm' f p.toReal μ < ⊤

tactic: exact ENNReal.toReal_pos hp_ne_zero hp_ne_top
state_before: case hq0_lt
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hfp : snorm f p μ < ⊤
⊢ 0 < p.toReal
state_after: no goals

tactic: simpa [snorm_eq_snorm' hp_ne_zero hp_ne_top] using hfp
state_before: case hfq
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hfp : snorm f p μ < ⊤
⊢ snorm' f p.toReal μ < ⊤
state_after: no goals
Theorem: List.formPerm_eq_head_iff_eq_getLast
File: Mathlib/GroupTheory/Perm/List.lean

tactic: rw [formPerm_apply_getLast]
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x✝ x y : α
⊢ (y :: l).formPerm x = y ↔ (y :: l).formPerm x = (y :: l).formPerm ((y :: l).getLast ⋯)
state_after: no goals
Theorem: Finset.image₂_mk_eq_product
File: Mathlib/Data/Finset/NAry.lean

tactic: ext
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁹ : DecidableEq α'
inst✝⁸ : DecidableEq β'
inst✝⁷ : DecidableEq γ
inst✝⁶ : DecidableEq γ'
inst✝⁵ : DecidableEq δ
inst✝⁴ : DecidableEq δ'
inst✝³ : DecidableEq ε
inst✝² : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s✝ s' : Finset α
t✝ t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
s : Finset α
t : Finset β
⊢ image₂ Prod.mk s t = s ×ˢ t
state_after: case a
α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁹ : DecidableEq α'
inst✝⁸ : DecidableEq β'
inst✝⁷ : DecidableEq γ
inst✝⁶ : DecidableEq γ'
inst✝⁵ : DecidableEq δ
inst✝⁴ : DecidableEq δ'
inst✝³ : DecidableEq ε
inst✝² : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s✝ s' : Finset α
t✝ t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
s : Finset α
t : Finset β
a✝ : α × β
⊢ a✝ ∈ image₂ Prod.mk s t ↔ a✝ ∈ s ×ˢ t

tactic: simp [Prod.ext_iff]
state_before: case a
α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁹ : DecidableEq α'
inst✝⁸ : DecidableEq β'
inst✝⁷ : DecidableEq γ
inst✝⁶ : DecidableEq γ'
inst✝⁵ : DecidableEq δ
inst✝⁴ : DecidableEq δ'
inst✝³ : DecidableEq ε
inst✝² : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s✝ s' : Finset α
t✝ t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
s : Finset α
t : Finset β
a✝ : α × β
⊢ a✝ ∈ image₂ Prod.mk s t ↔ a✝ ∈ s ×ˢ t
state_after: no goals
Theorem: WittVector.coeff_p_pow
File: Mathlib/RingTheory/WittVector/Identities.lean

tactic: induction' i with i h
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CharP R p
i : ℕ
⊢ (↑p ^ i).coeff i = 1
state_after: case zero
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CharP R p
⊢ (↑p ^ 0).coeff 0 = 1

case succ
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CharP R p
i : ℕ
h : (↑p ^ i).coeff i = 1
⊢ (↑p ^ (i + 1)).coeff (i + 1) = 1

tactic: simp only [Nat.zero_eq, one_coeff_zero, Ne, pow_zero]
state_before: case zero
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CharP R p
⊢ (↑p ^ 0).coeff 0 = 1
state_after: no goals

tactic: rw [pow_succ, ← frobenius_verschiebung, coeff_frobenius_charP,
  verschiebung_coeff_succ, h, one_pow]
state_before: case succ
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CharP R p
i : ℕ
h : (↑p ^ i).coeff i = 1
⊢ (↑p ^ (i + 1)).coeff (i + 1) = 1
state_after: no goals
Theorem: PNat.gcd_eq_right_iff_dvd
File: Mathlib/Data/PNat/Prime.lean

tactic: rw [gcd_comm]
state_before: m n : ℕ+
⊢ m ∣ n ↔ n.gcd m = m
state_after: m n : ℕ+
⊢ m ∣ n ↔ m.gcd n = m

tactic: apply gcd_eq_left_iff_dvd
state_before: m n : ℕ+
⊢ m ∣ n ↔ m.gcd n = m
state_after: no goals
Theorem: StrictConvexSpace.of_strictConvex_closed_unit_ball
File: Mathlib/Analysis/Convex/StrictConvexSpace.lean

tactic: simpa only [smul_closedUnitBall_of_nonneg hr.le] using h.smul r
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : NormedLinearOrderedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : LinearMap.CompatibleSMul E E 𝕜 ℝ
h : StrictConvex 𝕜 (closedBall 0 1)
r : ℝ
hr : 0 < r
⊢ StrictConvex 𝕜 (closedBall 0 r)
state_after: no goals
Theorem: Module.End.hasEigenvalue_iff_mem_spectrum
File: Mathlib/LinearAlgebra/Eigenspace/Basic.lean

tactic: rw [spectrum.mem_iff, IsUnit.sub_iff, LinearMap.isUnit_iff_ker_eq_bot, HasEigenvalue, eigenspace]
state_before: K R : Type v
V M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
⊢ f.HasEigenvalue μ ↔ μ ∈ spectrum K f
state_after: no goals
Theorem: Finset.filter_and
File: Mathlib/Data/Finset/Basic.lean

tactic: simp [mem_filter, mem_inter, and_comm, and_left_comm, and_self_iff, and_assoc]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
s✝ : Finset α
inst✝ : DecidableEq α
s : Finset α
x✝ : α
⊢ x✝ ∈ filter (fun a => p a ∧ q a) s ↔ x✝ ∈ filter p s ∩ filter q s
state_after: no goals
Theorem: Matrix.inv_zpow'
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

tactic: rw [zpow_neg h, inv_zpow]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit A.det
n : ℤ
⊢ A⁻¹ ^ n = A ^ (-n)
state_after: no goals
Theorem: CategoryTheory.Abelian.Pseudoelement.zero_of_map_zero
File: Mathlib/CategoryTheory/Abelian/Pseudoelements.lean

tactic: rw [← apply_zero f] at ha
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
P Q : C
f : P ⟶ Q
h : Function.Injective (pseudoApply f)
a : Pseudoelement P
ha : pseudoApply f a = 0
⊢ a = 0
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
P Q : C
f : P ⟶ Q
h : Function.Injective (pseudoApply f)
a : Pseudoelement P
ha : pseudoApply f a = pseudoApply f 0
⊢ a = 0

tactic: exact h ha
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
P Q : C
f : P ⟶ Q
h : Function.Injective (pseudoApply f)
a : Pseudoelement P
ha : pseudoApply f a = pseudoApply f 0
⊢ a = 0
state_after: no goals
Theorem: EuclideanGeometry.inversion_mem_perpBisector_inversion_iff'
File: Mathlib/Geometry/Euclidean/Inversion/ImageHyperplane.lean

tactic: rcases eq_or_ne x c with rfl | hx
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
c x y : P
R : ℝ
hR : R ≠ 0
hy : y ≠ c
⊢ inversion c R x ∈ perpBisector c (inversion c R y) ↔ dist x y = dist y c ∧ x ≠ c
state_after: case inl
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
x y : P
R : ℝ
hR : R ≠ 0
hy : y ≠ x
⊢ inversion x R x ∈ perpBisector x (inversion x R y) ↔ dist x y = dist y x ∧ x ≠ x

case inr
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
c x y : P
R : ℝ
hR : R ≠ 0
hy : y ≠ c
hx : x ≠ c
⊢ inversion c R x ∈ perpBisector c (inversion c R y) ↔ dist x y = dist y c ∧ x ≠ c

tactic: simp [*]
state_before: case inl
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
x y : P
R : ℝ
hR : R ≠ 0
hy : y ≠ x
⊢ inversion x R x ∈ perpBisector x (inversion x R y) ↔ dist x y = dist y x ∧ x ≠ x
state_after: no goals

tactic: simp [inversion_mem_perpBisector_inversion_iff hR hx hy, hx]
state_before: case inr
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
c x y : P
R : ℝ
hR : R ≠ 0
hy : y ≠ c
hx : x ≠ c
⊢ inversion c R x ∈ perpBisector c (inversion c R y) ↔ dist x y = dist y c ∧ x ≠ c
state_after: no goals
Theorem: HomogeneousIdeal.toIdeal_iSup₂
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

tactic: simp_rw [toIdeal_iSup]
state_before: ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
κ : Sort u_5
κ' : κ → Sort u_6
s : (i : κ) → κ' i → HomogeneousIdeal 𝒜
⊢ (⨆ i, ⨆ j, s i j).toIdeal = ⨆ i, ⨆ j, (s i j).toIdeal
state_after: no goals
Theorem: Summable.of_norm_bounded
File: Mathlib/Analysis/Normed/Group/InfiniteSum.lean

tactic: rw [summable_iff_cauchySeq_finset]
state_before: ι : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝² : SeminormedAddCommGroup E
inst✝¹ : SeminormedAddCommGroup F
inst✝ : CompleteSpace E
f : ι → E
g : ι → ℝ
hg : Summable g
h : ∀ (i : ι), ‖f i‖ ≤ g i
⊢ Summable f
state_after: ι : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝² : SeminormedAddCommGroup E
inst✝¹ : SeminormedAddCommGroup F
inst✝ : CompleteSpace E
f : ι → E
g : ι → ℝ
hg : Summable g
h : ∀ (i : ι), ‖f i‖ ≤ g i
⊢ CauchySeq fun s => ∑ b ∈ s, f b

tactic: exact cauchySeq_finset_of_norm_bounded g hg h
state_before: ι : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝² : SeminormedAddCommGroup E
inst✝¹ : SeminormedAddCommGroup F
inst✝ : CompleteSpace E
f : ι → E
g : ι → ℝ
hg : Summable g
h : ∀ (i : ι), ‖f i‖ ≤ g i
⊢ CauchySeq fun s => ∑ b ∈ s, f b
state_after: no goals
Theorem: Ideal.Quotient.factor_comp_mk
File: Mathlib/RingTheory/Ideal/Quotient.lean

tactic: ext x
state_before: R : Type u
inst✝¹ : CommRing R
I : Ideal R
a b : R
S✝ : Type v
x y : R
inst✝ : Semiring S✝
S T : Ideal R
H : S ≤ T
⊢ (factor S T H).comp (mk S) = mk T
state_after: case a
R : Type u
inst✝¹ : CommRing R
I : Ideal R
a b : R
S✝ : Type v
x✝ y : R
inst✝ : Semiring S✝
S T : Ideal R
H : S ≤ T
x : R
⊢ ((factor S T H).comp (mk S)) x = (mk T) x

tactic: rw [RingHom.comp_apply, factor_mk]
state_before: case a
R : Type u
inst✝¹ : CommRing R
I : Ideal R
a b : R
S✝ : Type v
x✝ y : R
inst✝ : Semiring S✝
S T : Ideal R
H : S ≤ T
x : R
⊢ ((factor S T H).comp (mk S)) x = (mk T) x
state_after: no goals
Theorem: Polynomial.X_mul_divX_add
File: Mathlib/Algebra/Polynomial/Inductions.lean

tactic: rintro ⟨_ | _⟩ <;> simp [coeff_C, Nat.succ_ne_zero, coeff_mul_X]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p✝ q p : R[X]
⊢ ∀ (n : ℕ), (X * p.divX + C (p.coeff 0)).coeff n = p.coeff n
state_after: no goals
Theorem: SetTheory.PGame.wf_isOption
File: Mathlib/SetTheory/Game/PGame.lean

tactic: induction' h with _ i _ j
state_before: x✝ x : PGame
IHl : ∀ (i : x.LeftMoves), Acc IsOption (x.moveLeft i)
IHr : ∀ (j : x.RightMoves), Acc IsOption (x.moveRight j)
y : PGame
h : y.IsOption x
⊢ Acc IsOption y
state_after: case moveLeft
x✝¹ x y x✝ : PGame
i : x✝.LeftMoves
IHl : ∀ (i : x✝.LeftMoves), Acc IsOption (x✝.moveLeft i)
IHr : ∀ (j : x✝.RightMoves), Acc IsOption (x✝.moveRight j)
⊢ Acc IsOption (x✝.moveLeft i)

case moveRight
x✝¹ x y x✝ : PGame
j : x✝.RightMoves
IHl : ∀ (i : x✝.LeftMoves), Acc IsOption (x✝.moveLeft i)
IHr : ∀ (j : x✝.RightMoves), Acc IsOption (x✝.moveRight j)
⊢ Acc IsOption (x✝.moveRight j)

tactic: exact IHl i
state_before: case moveLeft
x✝¹ x y x✝ : PGame
i : x✝.LeftMoves
IHl : ∀ (i : x✝.LeftMoves), Acc IsOption (x✝.moveLeft i)
IHr : ∀ (j : x✝.RightMoves), Acc IsOption (x✝.moveRight j)
⊢ Acc IsOption (x✝.moveLeft i)
state_after: no goals

tactic: exact IHr j
state_before: case moveRight
x✝¹ x y x✝ : PGame
j : x✝.RightMoves
IHl : ∀ (i : x✝.LeftMoves), Acc IsOption (x✝.moveLeft i)
IHr : ∀ (j : x✝.RightMoves), Acc IsOption (x✝.moveRight j)
⊢ Acc IsOption (x✝.moveRight j)
state_after: no goals
Theorem: torusIntegral_sub
File: Mathlib/MeasureTheory/Integral/TorusIntegral.lean

tactic: simpa only [sub_eq_add_neg, ← torusIntegral_neg] using torusIntegral_add hf hg.neg
state_before: n : ℕ
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f g : (Fin n → ℂ) → E
c : Fin n → ℂ
R : Fin n → ℝ
hf : TorusIntegrable f c R
hg : TorusIntegrable g c R
⊢ (∯ (x : Fin n → ℂ) in T(c, R), f x - g x) = (∯ (x : Fin n → ℂ) in T(c, R), f x) - ∯ (x : Fin n → ℂ) in T(c, R), g x
state_after: no goals
Theorem: EuclideanDomain.mod_add_div'
File: Mathlib/Algebra/EuclideanDomain/Defs.lean

tactic: rw [mul_comm]
state_before: R : Type u
inst✝ : EuclideanDomain R
m k : R
⊢ m % k + m / k * k = m
state_after: R : Type u
inst✝ : EuclideanDomain R
m k : R
⊢ m % k + k * (m / k) = m

tactic: exact mod_add_div _ _
state_before: R : Type u
inst✝ : EuclideanDomain R
m k : R
⊢ m % k + k * (m / k) = m
state_after: no goals
Theorem: Cycle.formPerm_apply_mem_eq_next
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: induction s using Quot.inductionOn
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ s' s : Cycle α
h : s.Nodup
x : α
hx : x ∈ s
⊢ (s.formPerm h) x = s.next h x hx
state_after: case h
α : Type u_1
inst✝ : DecidableEq α
s s' : Cycle α
x : α
a✝ : List α
h : Nodup (Quot.mk Setoid.r a✝)
hx : x ∈ Quot.mk Setoid.r a✝
⊢ (formPerm (Quot.mk Setoid.r a✝) h) x = next (Quot.mk Setoid.r a✝) h x hx

tactic: simpa using List.formPerm_apply_mem_eq_next h _ (by simp_all)
state_before: case h
α : Type u_1
inst✝ : DecidableEq α
s s' : Cycle α
x : α
a✝ : List α
h : Nodup (Quot.mk Setoid.r a✝)
hx : x ∈ Quot.mk Setoid.r a✝
⊢ (formPerm (Quot.mk Setoid.r a✝) h) x = next (Quot.mk Setoid.r a✝) h x hx
state_after: no goals

tactic: simp_all
state_before: α : Type u_1
inst✝ : DecidableEq α
s s' : Cycle α
x : α
a✝ : List α
h : Nodup (Quot.mk Setoid.r a✝)
hx : x ∈ Quot.mk Setoid.r a✝
⊢ x ∈ a✝
state_after: no goals
Theorem: MeasureTheory.Content.outerMeasure_exists_compact
File: Mathlib/MeasureTheory/Measure/Content.lean

tactic: rw [μ.outerMeasure_opens] at hU ⊢
state_before: G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : R1Space G
U : Opens G
hU : μ.outerMeasure ↑U ≠ ⊤
ε : ℝ≥0
hε : ε ≠ 0
⊢ ∃ K, ↑K ⊆ ↑U ∧ μ.outerMeasure ↑U ≤ μ.outerMeasure ↑K + ↑ε
state_after: G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : R1Space G
U : Opens G
hU : μ.innerContent U ≠ ⊤
ε : ℝ≥0
hε : ε ≠ 0
⊢ ∃ K, ↑K ⊆ ↑U ∧ μ.innerContent U ≤ μ.outerMeasure ↑K + ↑ε

tactic: rcases μ.innerContent_exists_compact hU hε with ⟨K, h1K, h2K⟩
state_before: G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : R1Space G
U : Opens G
hU : μ.innerContent U ≠ ⊤
ε : ℝ≥0
hε : ε ≠ 0
⊢ ∃ K, ↑K ⊆ ↑U ∧ μ.innerContent U ≤ μ.outerMeasure ↑K + ↑ε
state_after: case intro.intro
G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : R1Space G
U : Opens G
hU : μ.innerContent U ≠ ⊤
ε : ℝ≥0
hε : ε ≠ 0
K : Compacts G
h1K : ↑K ⊆ ↑U
h2K : μ.innerContent U ≤ (fun s => ↑(μ.toFun s)) K + ↑ε
⊢ ∃ K, ↑K ⊆ ↑U ∧ μ.innerContent U ≤ μ.outerMeasure ↑K + ↑ε

tactic: exact ⟨K, h1K, le_trans h2K <| add_le_add_right (μ.le_outerMeasure_compacts K) _⟩
state_before: case intro.intro
G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : R1Space G
U : Opens G
hU : μ.innerContent U ≠ ⊤
ε : ℝ≥0
hε : ε ≠ 0
K : Compacts G
h1K : ↑K ⊆ ↑U
h2K : μ.innerContent U ≤ (fun s => ↑(μ.toFun s)) K + ↑ε
⊢ ∃ K, ↑K ⊆ ↑U ∧ μ.innerContent U ≤ μ.outerMeasure ↑K + ↑ε
state_after: no goals
Theorem: Antitone.map_max
File: Mathlib/Order/MinMax.lean

tactic: rcases le_total a b with h | h <;> simp [h, hf h]
state_before: α : Type u
β : Type v
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a b c d : α
hf : Antitone f
⊢ f (max a b) = min (f a) (f b)
state_after: no goals
Theorem: Denumerable.sigma_ofNat_val
File: Mathlib/Logic/Denumerable.lean

tactic: rw [← decode_eq_ofNat, decode_sigma_val]
state_before: α : Type u_1
β : Type u_2
inst✝² : Denumerable α
inst✝¹ : Denumerable β
γ : α → Type u_3
inst✝ : (a : α) → Denumerable (γ a)
n : ℕ
⊢ some (ofNat (Sigma γ) n) = some ⟨ofNat α (unpair n).1, ofNat (γ (ofNat α (unpair n).1)) (unpair n).2⟩
state_after: α : Type u_1
β : Type u_2
inst✝² : Denumerable α
inst✝¹ : Denumerable β
γ : α → Type u_3
inst✝ : (a : α) → Denumerable (γ a)
n : ℕ
⊢ ((decode (unpair n).1).bind fun a => Option.map (Sigma.mk a) (decode (unpair n).2)) =
    some ⟨ofNat α (unpair n).1, ofNat (γ (ofNat α (unpair n).1)) (unpair n).2⟩

tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝² : Denumerable α
inst✝¹ : Denumerable β
γ : α → Type u_3
inst✝ : (a : α) → Denumerable (γ a)
n : ℕ
⊢ ((decode (unpair n).1).bind fun a => Option.map (Sigma.mk a) (decode (unpair n).2)) =
    some ⟨ofNat α (unpair n).1, ofNat (γ (ofNat α (unpair n).1)) (unpair n).2⟩
state_after: no goals