ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Algebra.adjoin_inl_union_inr_eq_prod
File: Mathlib/RingTheory/Adjoin/Basic.lean

Proof steps:
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
inst✝⁸ : CommSemiring R
inst✝⁷ : CommSemiring S
inst✝⁶ : Semiring A
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R S
inst✝³ : Algebra R A
inst✝² : Algebra S A
inst✝¹ : Algebra R B
inst✝ : IsScalarTower R S A
s✝ t✝ s : Set A
t : Set B
⊢ adjoin R (⇑(LinearMap.inl R A B) '' (s ∪ {1}) ∪ ⇑(LinearMap.inr R A B) '' (t ∪ {1})) = (adjoin R s).prod (adjoin R t)
state_after: case a
R : Type uR
S : Type uS
A : Type uA
B : Type uB
inst✝⁸ : CommSemiring R
inst✝⁷ : CommSemiring S
inst✝⁶ : Semiring A
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R S
inst✝³ : Algebra R A
inst✝² : Algebra S A
inst✝¹ : Algebra R B
inst✝ : IsScalarTower R S A
s✝ t✝ s : Set A
t : Set B
⊢ adjoin R (⇑(LinearMap.inl R A B) '' (s ∪ {1}) ∪ ⇑(LinearMap.inr R A B) '' (t ∪ {1})) ≤ (adjoin R s).prod (adjoin R t)

case a
R : Type uR
S : Type uS
A : Type uA
B : Type uB
inst✝⁸ : CommSemiring R
inst✝⁷ : CommSemiring S
inst✝⁶ : Semiring A
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R S
inst✝³ : Algebra R A
inst✝² : Algebra S A
inst✝¹ : Algebra R B
inst✝ : IsScalarTower R S A
s✝ t✝ s : Set A
t : Set B
⊢ (adjoin R s).prod (adjoin R t) ≤ adjoin R (⇑(LinearMap.inl R A B) '' (s ∪ {1}) ∪ ⇑(LinearMap.inr R A B) '' (t ∪ {1}))
tactic: apply le_antisymm
Theorem: isQuasiregular_iff_isUnit
File: Mathlib/Algebra/Algebra/Quasispectrum.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Ring R
x : R
⊢ IsQuasiregular x ↔ IsUnit (1 + x)
state_after: R : Type u_1
inst✝ : Ring R
x : R
hx : IsUnit (1 + x)
⊢ IsQuasiregular x
tactic: refine ⟨IsQuasiregular.isUnit_one_add, fun hx ↦ ?_⟩
state_before: R : Type u_1
inst✝ : Ring R
x : R
hx : IsUnit (1 + x)
⊢ IsQuasiregular x
state_after: R : Type u_1
inst✝ : Ring R
x : R
hx : IsUnit (1 + x)
⊢ ∃ y, y + x + x * y = 0 ∧ x + y + y * x = 0
tactic: rw [isQuasiregular_iff]
state_before: R : Type u_1
inst✝ : Ring R
x : R
hx : IsUnit (1 + x)
⊢ ∃ y, y + x + x * y = 0 ∧ x + y + y * x = 0
state_after: case h
R : Type u_1
inst✝ : Ring R
x : R
hx : IsUnit (1 + x)
⊢ ↑hx.unit⁻¹ - 1 + x + x * (↑hx.unit⁻¹ - 1) = 0 ∧ x + (↑hx.unit⁻¹ - 1) + (↑hx.unit⁻¹ - 1) * x = 0
tactic: use hx.unit⁻¹ - 1
state_before: case h
R : Type u_1
inst✝ : Ring R
x : R
hx : IsUnit (1 + x)
⊢ ↑hx.unit⁻¹ - 1 + x + x * (↑hx.unit⁻¹ - 1) = 0 ∧ x + (↑hx.unit⁻¹ - 1) + (↑hx.unit⁻¹ - 1) * x = 0
state_after: case h.left
R : Type u_1
inst✝ : Ring R
x : R
hx : IsUnit (1 + x)
⊢ ↑hx.unit⁻¹ - 1 + x + x * (↑hx.unit⁻¹ - 1) = 0

case h.right
R : Type u_1
inst✝ : Ring R
x : R
hx : IsUnit (1 + x)
⊢ x + (↑hx.unit⁻¹ - 1) + (↑hx.unit⁻¹ - 1) * x = 0
tactic: constructor
state_before: case h.left
R : Type u_1
inst✝ : Ring R
x : R
hx : IsUnit (1 + x)
⊢ ↑hx.unit⁻¹ - 1 + x + x * (↑hx.unit⁻¹ - 1) = 0

case h.right
R : Type u_1
inst✝ : Ring R
x : R
hx : IsUnit (1 + x)
⊢ x + (↑hx.unit⁻¹ - 1) + (↑hx.unit⁻¹ - 1) * x = 0
state_after: case h.left
R : Type u_1
inst✝ : Ring R
x : R
hx : IsUnit (1 + x)
this : (1 + x) * ↑hx.unit⁻¹ - 1 = 1 - 1
⊢ ↑hx.unit⁻¹ - 1 + x + x * (↑hx.unit⁻¹ - 1) = 0

case h.right
R : Type u_1
inst✝ : Ring R
x : R
hx : IsUnit (1 + x)
⊢ x + (↑hx.unit⁻¹ - 1) + (↑hx.unit⁻¹ - 1) * x = 0
tactic: case' h.left => have := congr($(hx.mul_val_inv) - 1)
state_before: case h.left
R : Type u_1
inst✝ : Ring R
x : R
hx : IsUnit (1 + x)
this : (1 + x) * ↑hx.unit⁻¹ - 1 = 1 - 1
⊢ ↑hx.unit⁻¹ - 1 + x + x * (↑hx.unit⁻¹ - 1) = 0

case h.right
R : Type u_1
inst✝ : Ring R
x : R
hx : IsUnit (1 + x)
⊢ x + (↑hx.unit⁻¹ - 1) + (↑hx.unit⁻¹ - 1) * x = 0
state_after: case h.right
R : Type u_1
inst✝ : Ring R
x : R
hx : IsUnit (1 + x)
this : ↑hx.unit⁻¹ * (1 + x) - 1 = 1 - 1
⊢ x + (↑hx.unit⁻¹ - 1) + (↑hx.unit⁻¹ - 1) * x = 0

case h.left
R : Type u_1
inst✝ : Ring R
x : R
hx : IsUnit (1 + x)
this : (1 + x) * ↑hx.unit⁻¹ - 1 = 1 - 1
⊢ ↑hx.unit⁻¹ - 1 + x + x * (↑hx.unit⁻¹ - 1) = 0
tactic: case' h.right => have := congr($(hx.val_inv_mul) - 1)
state_before: case h.right
R : Type u_1
inst✝ : Ring R
x : R
hx : IsUnit (1 + x)
this : ↑hx.unit⁻¹ * (1 + x) - 1 = 1 - 1
⊢ x + (↑hx.unit⁻¹ - 1) + (↑hx.unit⁻¹ - 1) * x = 0

case h.left
R : Type u_1
inst✝ : Ring R
x : R
hx : IsUnit (1 + x)
this : (1 + x) * ↑hx.unit⁻¹ - 1 = 1 - 1
⊢ ↑hx.unit⁻¹ - 1 + x + x * (↑hx.unit⁻¹ - 1) = 0
state_after: no goals
tactic: all_goals
    rw [← sub_add_cancel (↑hx.unit⁻¹ : R) 1, sub_self] at this
    convert this using 1
    noncomm_ring
Theorem: PNat.Coprime.factor_eq_gcd_right
File: Mathlib/Data/PNat/Prime.lean

Proof steps:
state_before: a b m n : ℕ+
cop : m.Coprime n
am : a ∣ m
bn : b ∣ n
⊢ a = (b * a).gcd m
state_after: a b m n : ℕ+
cop : m.Coprime n
am : a ∣ m
bn : b ∣ n
⊢ a = (a * b).gcd m
tactic: rw [mul_comm]
state_before: a b m n : ℕ+
cop : m.Coprime n
am : a ∣ m
bn : b ∣ n
⊢ a = (a * b).gcd m
state_after: no goals
tactic: apply Coprime.factor_eq_gcd_left cop am bn
Theorem: vadd_iterate
File: Mathlib/Algebra/GroupPower/IterateHom.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
G : Type u_3
H : Type u_4
inst✝¹ : Monoid G
a : G
n : ℕ
inst✝ : MulAction G H
b : H
⊢ (fun x => a • x)^[Nat.zero] b = a ^ Nat.zero • b
state_after: no goals
tactic: rw [iterate_zero, id, pow_zero, one_smul]
state_before: M : Type u_1
N : Type u_2
G : Type u_3
H : Type u_4
inst✝¹ : Monoid G
a : G
n✝ : ℕ
inst✝ : MulAction G H
b : H
n : ℕ
ih : (fun x => a • x)^[n] b = a ^ n • b
⊢ (fun x => a • x)^[n.succ] b = a ^ n.succ • b
state_after: no goals
tactic: rw [iterate_succ', comp_apply, ih, pow_succ', mul_smul]
Theorem: Nat.pred_iterate
File: Mathlib/Data/Nat/SuccPred.lean

Proof steps:
state_before: m n✝ a n : ℕ
⊢ pred^[n + 1] a = a - (n + 1)
state_after: m n✝ a n : ℕ
⊢ (pred ∘ pred^[n]) a = (a - n).pred
tactic: rw [Function.iterate_succ', sub_succ]
state_before: m n✝ a n : ℕ
⊢ (pred ∘ pred^[n]) a = (a - n).pred
state_after: no goals
tactic: exact congr_arg _ (pred_iterate a n)
Theorem: Matrix.isUnit_diagonal
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

Proof steps:
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
v : n → α
⊢ IsUnit (diagonal v) ↔ IsUnit v
state_after: no goals
tactic: simp only [← nonempty_invertible_iff_isUnit,
    (diagonalInvertibleEquivInvertible v).nonempty_congr]
Theorem: BooleanRing.sup_assoc
File: Mathlib/Algebra/Ring/BooleanRing.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : BooleanRing α
inst✝¹ : BooleanRing β
inst✝ : BooleanRing γ
a b c : α
⊢ a + b + a * b + c + (a + b + a * b) * c = a + (b + c + b * c) + a * (b + c + b * c)
state_after: no goals
tactic: ring
Theorem: AddSubgroup.codisjoint_addSubgroupOf_sup
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
f : G →* N
H K : Subgroup G
⊢ Codisjoint (H.subgroupOf (H ⊔ K)) (K.subgroupOf (H ⊔ K))
state_after: case hH
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
f : G →* N
H K : Subgroup G
⊢ H ≤ H ⊔ K

case hK
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
f : G →* N
H K : Subgroup G
⊢ K ≤ H ⊔ K
tactic: rw [codisjoint_iff, sup_subgroupOf_eq, subgroupOf_self]
state_before: case hH
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
f : G →* N
H K : Subgroup G
⊢ H ≤ H ⊔ K

case hK
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
f : G →* N
H K : Subgroup G
⊢ K ≤ H ⊔ K
state_after: no goals
tactic: exacts [le_sup_left, le_sup_right]
Theorem: ConcaveOn.smul''
File: Mathlib/Analysis/Convex/Mul.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹⁰ : LinearOrderedCommRing 𝕜
inst✝⁹ : LinearOrderedCommRing E
inst✝⁸ : LinearOrderedAddCommGroup F
inst✝⁷ : Module 𝕜 E
inst✝⁶ : Module 𝕜 F
inst✝⁵ : Module E F
inst✝⁴ : IsScalarTower 𝕜 E F
inst✝³ : SMulCommClass 𝕜 E F
inst✝² : OrderedSMul 𝕜 E
inst✝¹ : OrderedSMul 𝕜 F
inst✝ : OrderedSMul E F
s : Set 𝕜
f : 𝕜 → E
g : 𝕜 → F
hf : ConcaveOn 𝕜 s f
hg : ConcaveOn 𝕜 s g
hf₀ : ∀ ⦃x : 𝕜⦄, x ∈ s → f x ≤ 0
hg₀ : ∀ ⦃x : 𝕜⦄, x ∈ s → g x ≤ 0
hfg : MonovaryOn f g s
⊢ ConvexOn 𝕜 s (f • g)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹⁰ : LinearOrderedCommRing 𝕜
inst✝⁹ : LinearOrderedCommRing E
inst✝⁸ : LinearOrderedAddCommGroup F
inst✝⁷ : Module 𝕜 E
inst✝⁶ : Module 𝕜 F
inst✝⁵ : Module E F
inst✝⁴ : IsScalarTower 𝕜 E F
inst✝³ : SMulCommClass 𝕜 E F
inst✝² : OrderedSMul 𝕜 E
inst✝¹ : OrderedSMul 𝕜 F
inst✝ : OrderedSMul E F
s : Set 𝕜
f : 𝕜 → E
g : 𝕜 → F
hf : ConcaveOn 𝕜 s f
hg : ConcaveOn 𝕜 s g
hf₀ : ∀ ⦃x : 𝕜⦄, x ∈ s → f x ≤ 0
hg₀ : ∀ ⦃x : 𝕜⦄, x ∈ s → g x ≤ 0
hfg : MonovaryOn f g s
⊢ ConvexOn 𝕜 s (-f • -g)
tactic: rw [← neg_smul_neg]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹⁰ : LinearOrderedCommRing 𝕜
inst✝⁹ : LinearOrderedCommRing E
inst✝⁸ : LinearOrderedAddCommGroup F
inst✝⁷ : Module 𝕜 E
inst✝⁶ : Module 𝕜 F
inst✝⁵ : Module E F
inst✝⁴ : IsScalarTower 𝕜 E F
inst✝³ : SMulCommClass 𝕜 E F
inst✝² : OrderedSMul 𝕜 E
inst✝¹ : OrderedSMul 𝕜 F
inst✝ : OrderedSMul E F
s : Set 𝕜
f : 𝕜 → E
g : 𝕜 → F
hf : ConcaveOn 𝕜 s f
hg : ConcaveOn 𝕜 s g
hf₀ : ∀ ⦃x : 𝕜⦄, x ∈ s → f x ≤ 0
hg₀ : ∀ ⦃x : 𝕜⦄, x ∈ s → g x ≤ 0
hfg : MonovaryOn f g s
⊢ ConvexOn 𝕜 s (-f • -g)
state_after: no goals
tactic: exact hf.neg.smul' hg.neg (fun x hx ↦ neg_nonneg.2 <| hf₀ hx) (fun x hx ↦ neg_nonneg.2 <| hg₀ hx)
    hfg.neg
Theorem: LieDerivation.injective_ad_of_center_eq_bot
File: Mathlib/Algebra/Lie/Derivation/AdjointAction.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
h : LieAlgebra.center R L = ⊥
⊢ Function.Injective ⇑(ad R L)
state_after: no goals
tactic: rw [← LieHom.ker_eq_bot, ad_ker_eq_center, h]
Theorem: MeasureTheory.measurePreserving_smul
File: Mathlib/MeasureTheory/Group/Action.lean

Proof steps:
state_before: G : Type u
M : Type v
α : Type w
s : Set α
m : MeasurableSpace α
inst✝³ : MeasurableSpace M
inst✝² : SMul M α
inst✝¹ : MeasurableSMul M α
c : M
μ : Measure α
inst✝ : SMulInvariantMeasure M α μ
⊢ Measure.map (fun x => c • x) μ = μ
state_after: case h
G : Type u
M : Type v
α : Type w
s✝ : Set α
m : MeasurableSpace α
inst✝³ : MeasurableSpace M
inst✝² : SMul M α
inst✝¹ : MeasurableSMul M α
c : M
μ : Measure α
inst✝ : SMulInvariantMeasure M α μ
s : Set α
hs : MeasurableSet s
⊢ (Measure.map (fun x => c • x) μ) s = μ s
tactic: ext1 s hs
state_before: case h
G : Type u
M : Type v
α : Type w
s✝ : Set α
m : MeasurableSpace α
inst✝³ : MeasurableSpace M
inst✝² : SMul M α
inst✝¹ : MeasurableSMul M α
c : M
μ : Measure α
inst✝ : SMulInvariantMeasure M α μ
s : Set α
hs : MeasurableSet s
⊢ (Measure.map (fun x => c • x) μ) s = μ s
state_after: case h
G : Type u
M : Type v
α : Type w
s✝ : Set α
m : MeasurableSpace α
inst✝³ : MeasurableSpace M
inst✝² : SMul M α
inst✝¹ : MeasurableSMul M α
c : M
μ : Measure α
inst✝ : SMulInvariantMeasure M α μ
s : Set α
hs : MeasurableSet s
⊢ μ ((fun x => c • x) ⁻¹' s) = μ s
tactic: rw [map_apply (measurable_const_smul c) hs]
state_before: case h
G : Type u
M : Type v
α : Type w
s✝ : Set α
m : MeasurableSpace α
inst✝³ : MeasurableSpace M
inst✝² : SMul M α
inst✝¹ : MeasurableSMul M α
c : M
μ : Measure α
inst✝ : SMulInvariantMeasure M α μ
s : Set α
hs : MeasurableSet s
⊢ μ ((fun x => c • x) ⁻¹' s) = μ s
state_after: no goals
tactic: exact SMulInvariantMeasure.measure_preimage_smul c hs
Theorem: CategoryTheory.MorphismProperty.inverseImage_iff
File: Mathlib/CategoryTheory/MorphismProperty/Basic.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{u_2, u_1} D
P : MorphismProperty D
F : C ⥤ D
X Y : C
f : X ⟶ Y
⊢ P.inverseImage F f ↔ P (F.map f)
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.levyProkhorovDist_self
File: Mathlib/MeasureTheory/Measure/LevyProkhorovMetric.lean

Proof steps:
state_before: ι : Type u_1
Ω : Type u_2
inst✝¹ : MeasurableSpace Ω
inst✝ : PseudoEMetricSpace Ω
μ : Measure Ω
⊢ levyProkhorovDist μ μ = 0
state_after: no goals
tactic: simp only [levyProkhorovDist, levyProkhorovEDist_self, zero_toReal]
Theorem: Int.pow_right_injective
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a b c d m n : ℤ
h : 1 < a.natAbs
⊢ Function.Injective (natAbs ∘ fun x => a ^ x)
state_after: case h.e'_3.h
a b c d m n : ℤ
h : 1 < a.natAbs
x✝ : ℕ
⊢ (natAbs ∘ fun x => a ^ x) x✝ = a.natAbs ^ x✝
tactic: convert Nat.pow_right_injective h using 2
state_before: case h.e'_3.h
a b c d m n : ℤ
h : 1 < a.natAbs
x✝ : ℕ
⊢ (natAbs ∘ fun x => a ^ x) x✝ = a.natAbs ^ x✝
state_after: no goals
tactic: rw [Function.comp_apply, natAbs_pow]
Theorem: Ordnode.Valid'.rotateL_lemma₃
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Preorder α
a b c : ℕ
H2 : 3 * a ≤ b + c
h : b < 2 * c
⊢ a + b < 3 * c
state_after: no goals
tactic: omega
Theorem: FirstOrder.Language.BoundedFormula.realize_rel₂
File: Mathlib/ModelTheory/Semantics.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
R : L.Relations 2
t₁ t₂ : L.Term (α ⊕ Fin l)
⊢ (R.boundedFormula₂ t₁ t₂).Realize v xs ↔ RelMap R ![realize (Sum.elim v xs) t₁, realize (Sum.elim v xs) t₂]
state_after: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
R : L.Relations 2
t₁ t₂ : L.Term (α ⊕ Fin l)
⊢ (RelMap R fun i => realize (Sum.elim v xs) (![t₁, t₂] i)) =
    RelMap R ![realize (Sum.elim v xs) t₁, realize (Sum.elim v xs) t₂]
tactic: rw [Relations.boundedFormula₂, realize_rel, iff_eq_eq]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
R : L.Relations 2
t₁ t₂ : L.Term (α ⊕ Fin l)
⊢ (RelMap R fun i => realize (Sum.elim v xs) (![t₁, t₂] i)) =
    RelMap R ![realize (Sum.elim v xs) t₁, realize (Sum.elim v xs) t₂]
state_after: case refine_1
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
R : L.Relations 2
t₁ t₂ : L.Term (α ⊕ Fin l)
⊢ realize (Sum.elim v xs) (![t₁, t₂] 0) = ![realize (Sum.elim v xs) t₁, realize (Sum.elim v xs) t₂] 0

case refine_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
R : L.Relations 2
t₁ t₂ : L.Term (α ⊕ Fin l)
⊢ ∀ (i : Fin 1),
    realize (Sum.elim v xs) (![t₁, t₂] i.succ) = ![realize (Sum.elim v xs) t₁, realize (Sum.elim v xs) t₂] i.succ
tactic: refine congr rfl (funext (Fin.cases ?_ ?_))
Theorem: QPF.Wequiv.abs'
File: Mathlib/Data/QPF/Univariate/Basic.lean

Proof steps:
state_before: F : Type u → Type u
q : QPF F
x y : (P F).W
h : QPF.abs x.dest = QPF.abs y.dest
⊢ Wequiv x y
state_after: case mk
F : Type u → Type u
q : QPF F
y : (P F).W
a✝ : (P F).A
f✝ : (P F).B a✝ → WType (P F).B
h : QPF.abs (PFunctor.W.dest (WType.mk a✝ f✝)) = QPF.abs y.dest
⊢ Wequiv (WType.mk a✝ f✝) y
tactic: cases x
state_before: case mk
F : Type u → Type u
q : QPF F
y : (P F).W
a✝ : (P F).A
f✝ : (P F).B a✝ → WType (P F).B
h : QPF.abs (PFunctor.W.dest (WType.mk a✝ f✝)) = QPF.abs y.dest
⊢ Wequiv (WType.mk a✝ f✝) y
state_after: case mk.mk
F : Type u → Type u
q : QPF F
a✝¹ : (P F).A
f✝¹ : (P F).B a✝¹ → WType (P F).B
a✝ : (P F).A
f✝ : (P F).B a✝ → WType (P F).B
h : QPF.abs (PFunctor.W.dest (WType.mk a✝¹ f✝¹)) = QPF.abs (PFunctor.W.dest (WType.mk a✝ f✝))
⊢ Wequiv (WType.mk a✝¹ f✝¹) (WType.mk a✝ f✝)
tactic: cases y
state_before: case mk.mk
F : Type u → Type u
q : QPF F
a✝¹ : (P F).A
f✝¹ : (P F).B a✝¹ → WType (P F).B
a✝ : (P F).A
f✝ : (P F).B a✝ → WType (P F).B
h : QPF.abs (PFunctor.W.dest (WType.mk a✝¹ f✝¹)) = QPF.abs (PFunctor.W.dest (WType.mk a✝ f✝))
⊢ Wequiv (WType.mk a✝¹ f✝¹) (WType.mk a✝ f✝)
state_after: case mk.mk.a
F : Type u → Type u
q : QPF F
a✝¹ : (P F).A
f✝¹ : (P F).B a✝¹ → WType (P F).B
a✝ : (P F).A
f✝ : (P F).B a✝ → WType (P F).B
h : QPF.abs (PFunctor.W.dest (WType.mk a✝¹ f✝¹)) = QPF.abs (PFunctor.W.dest (WType.mk a✝ f✝))
⊢ QPF.abs ⟨a✝¹, f✝¹⟩ = QPF.abs ⟨a✝, f✝⟩
tactic: apply Wequiv.abs
state_before: case mk.mk.a
F : Type u → Type u
q : QPF F
a✝¹ : (P F).A
f✝¹ : (P F).B a✝¹ → WType (P F).B
a✝ : (P F).A
f✝ : (P F).B a✝ → WType (P F).B
h : QPF.abs (PFunctor.W.dest (WType.mk a✝¹ f✝¹)) = QPF.abs (PFunctor.W.dest (WType.mk a✝ f✝))
⊢ QPF.abs ⟨a✝¹, f✝¹⟩ = QPF.abs ⟨a✝, f✝⟩
state_after: no goals
tactic: apply h
Theorem: add_sub_add_comm
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ a * b / (c * d) = a / c * (b / d)
state_after: no goals
tactic: simp
Theorem: Sum.bnot_isRight
File: .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
x : α ⊕ β
⊢ (!decide (x.isRight = x.isLeft)) = true
state_after: no goals
tactic: cases x <;> rfl
Theorem: Submonoid.LocalizationMap.lift_mk'
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
x : M
y : ↥S
⊢ f.toMap ((f.sec (f.mk' x y)).1 * ↑y) = f.toMap (x * ↑(f.sec (f.mk' x y)).2)
state_after: no goals
tactic: simp_rw [f.toMap.map_mul, sec_spec', mul_assoc, f.mk'_spec, mul_comm]
Theorem: ProbabilityTheory.condCount_inter'
File: Mathlib/Probability/CondCount.lean

Proof steps:
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : s.Finite
⊢ (condCount s) (t ∩ u) = (condCount (s ∩ u)) t * (condCount s) u
state_after: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : s.Finite
⊢ (condCount s) (u ∩ t) = (condCount (s ∩ u)) t * (condCount s) u
tactic: rw [← Set.inter_comm]
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : s.Finite
⊢ (condCount s) (u ∩ t) = (condCount (s ∩ u)) t * (condCount s) u
state_after: no goals
tactic: exact condCount_inter hs
Theorem: multiplicity.neg
File: Mathlib/RingTheory/Multiplicity.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
⊢ (multiplicity a (-b)).Dom ↔ (multiplicity a b).Dom
state_after: no goals
tactic: simp only [multiplicity, PartENat.find, dvd_neg]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
h₁ : (multiplicity a (-b)).Dom
h₂ : (multiplicity a b).Dom
⊢ ↑((multiplicity a (-b)).get h₁) = ↑((multiplicity a b).get h₂)
state_after: α : Type u_1
β : Type u_2
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
h₁ : (multiplicity a (-b)).Dom
h₂ : (multiplicity a b).Dom
⊢ multiplicity a (-b) = ↑((multiplicity a b).get h₂)
tactic: rw [PartENat.natCast_get]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
h₁ : (multiplicity a (-b)).Dom
h₂ : (multiplicity a b).Dom
⊢ multiplicity a (-b) = ↑((multiplicity a b).get h₂)
state_after: no goals
tactic: exact Eq.symm
              (unique (pow_multiplicity_dvd _).neg_right
                (mt dvd_neg.1 (is_greatest' _ (lt_succ_self _))))
Theorem: isClosedMap_const
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X✝ : Type u_1
Y✝ : Type u_2
inst✝³ : TopologicalSpace X✝
X : Type u_3
Y : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : T1Space Y
y : Y
s : Set X
x✝ : IsClosed s
h2s : s.Nonempty
⊢ IsClosed (const X y '' s)
state_after: no goals
tactic: simp_rw [const, h2s.image_const, isClosed_singleton]
Theorem: LaurentSeries.coeff_zero_of_lt_intValuation
File: Mathlib/RingTheory/LaurentSeries.lean

Proof steps:
state_before: R : Type u_1
K : Type u_2
inst✝ : Field K
n d : ℕ
f : K⟦X⟧
H : Valued.v ((ofPowerSeries ℤ K) f) ≤ ↑(Multiplicative.ofAdd (-↑d))
⊢ n < d → (PowerSeries.coeff K n) f = 0
state_after: R : Type u_1
K : Type u_2
inst✝ : Field K
n d : ℕ
f : K⟦X⟧
H : Valued.v ((ofPowerSeries ℤ K) f) ≤ ↑(Multiplicative.ofAdd (-↑d))
hnd : n < d
⊢ (PowerSeries.coeff K n) f = 0
tactic: intro hnd
state_before: R : Type u_1
K : Type u_2
inst✝ : Field K
n d : ℕ
f : K⟦X⟧
H : Valued.v ((ofPowerSeries ℤ K) f) ≤ ↑(Multiplicative.ofAdd (-↑d))
hnd : n < d
⊢ (PowerSeries.coeff K n) f = 0
state_after: R : Type u_1
K : Type u_2
inst✝ : Field K
n d : ℕ
f : K⟦X⟧
H : Valued.v ((ofPowerSeries ℤ K) f) ≤ ↑(Multiplicative.ofAdd (-↑d))
hnd : n < d
⊢ PowerSeries.X ^ d ∣ f
tactic: apply (PowerSeries.X_pow_dvd_iff).mp _ n hnd
state_before: R : Type u_1
K : Type u_2
inst✝ : Field K
n d : ℕ
f : K⟦X⟧
H : Valued.v ((ofPowerSeries ℤ K) f) ≤ ↑(Multiplicative.ofAdd (-↑d))
hnd : n < d
⊢ PowerSeries.X ^ d ∣ f
state_after: R : Type u_1
K : Type u_2
inst✝ : Field K
n d : ℕ
f : K⟦X⟧
H : Valued.v ((ofPowerSeries ℤ K) f) ≤ ↑(Multiplicative.ofAdd (-↑d))
hnd : n < d
⊢ (PowerSeries.idealX K).valuation ((algebraMap K⟦X⟧ (LaurentSeries K)) f) ≤ ↑(Multiplicative.ofAdd (-↑d))
tactic: erw [← span_singleton_dvd_span_singleton_iff_dvd, ← Ideal.span_singleton_pow,
    ← (intValuation_le_pow_iff_dvd (PowerSeries.idealX K) f d), ← intValuation_apply,
    ← valuation_of_algebraMap (R := K⟦X⟧) (K := (LaurentSeries K))]
state_before: R : Type u_1
K : Type u_2
inst✝ : Field K
n d : ℕ
f : K⟦X⟧
H : Valued.v ((ofPowerSeries ℤ K) f) ≤ ↑(Multiplicative.ofAdd (-↑d))
hnd : n < d
⊢ (PowerSeries.idealX K).valuation ((algebraMap K⟦X⟧ (LaurentSeries K)) f) ≤ ↑(Multiplicative.ofAdd (-↑d))
state_after: no goals
tactic: exact H
Theorem: CochainComplex.HomComplex.Cochain.map_sub
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

Proof steps:
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : Preadditive C
R : Type u_1
inst✝⁴ : Ring R
inst✝³ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
z z' : Cochain K L n
f : K ⟶ L
Φ : C ⥤ D
inst✝ : Φ.Additive
⊢ (z - z').map Φ = z.map Φ - z'.map Φ
state_after: no goals
tactic: aesop_cat
Theorem: ENNReal.rpow_inv_natCast_pow
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: n : ℕ
hn : n ≠ 0
x : ℝ≥0∞
⊢ (x ^ (↑n)⁻¹) ^ n = x
state_after: no goals
tactic: rw [← rpow_natCast, ← rpow_mul, inv_mul_cancel (by positivity), rpow_one]
Theorem: EReal.image_coe_Icc
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x y : ℝ
⊢ Real.toEReal '' Icc x y = Icc ↑x ↑y
state_after: x y : ℝ
⊢ WithBot.some '' (WithTop.some '' Icc x y) = Icc ↑x ↑y
tactic: refine (image_comp WithBot.some WithTop.some _).trans ?_
state_before: x y : ℝ
⊢ WithBot.some '' (WithTop.some '' Icc x y) = Icc ↑x ↑y
state_after: x y : ℝ
⊢ Icc ↑↑x ↑↑y = Icc ↑x ↑y
tactic: rw [WithTop.image_coe_Icc, WithBot.image_coe_Icc]
state_before: x y : ℝ
⊢ Icc ↑↑x ↑↑y = Icc ↑x ↑y
state_after: no goals
tactic: rfl