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

tactic: simp
state_before: a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
n : ℕ
⊢ (n • a).toReal = n • a.toReal
state_after: no goals
Theorem: Fin.predAbove_zero
File: Mathlib/Data/Fin/Basic.lean

tactic: split_ifs with hi
state_before: n m : ℕ
inst✝ : NeZero n
i : Fin (n + 1)
⊢ predAbove 0 i = if hi : i = 0 then 0 else i.pred hi
state_after: case pos
n m : ℕ
inst✝ : NeZero n
i : Fin (n + 1)
hi : i = 0
⊢ predAbove 0 i = 0

case neg
n m : ℕ
inst✝ : NeZero n
i : Fin (n + 1)
hi : ¬i = 0
⊢ predAbove 0 i = i.pred hi

tactic: rw [hi, predAbove_right_zero]
state_before: case pos
n m : ℕ
inst✝ : NeZero n
i : Fin (n + 1)
hi : i = 0
⊢ predAbove 0 i = 0
state_after: no goals

tactic: rw [predAbove_zero_of_ne_zero hi]
state_before: case neg
n m : ℕ
inst✝ : NeZero n
i : Fin (n + 1)
hi : ¬i = 0
⊢ predAbove 0 i = i.pred hi
state_after: no goals
Theorem: CategoryTheory.Sieve.pushforward_le_bind_of_mem
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: rintro Z _ ⟨g, rfl, hg⟩
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
S✝ R✝ : Sieve X
S : Presieve X
R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → Sieve Y
f : Y ⟶ X
h : S f
⊢ pushforward f (R h) ≤ bind S R
state_after: case intro.intro
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z✝ : C
f✝ : Y ⟶ X
S✝ R✝ : Sieve X
S : Presieve X
R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → Sieve Y
f : Y ⟶ X
h : S f
Z : C
g : Z ⟶ Y
hg : (R h).arrows g
⊢ (bind S R).arrows (g ≫ f)

tactic: exact ⟨_, g, f, h, hg, rfl⟩
state_before: case intro.intro
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z✝ : C
f✝ : Y ⟶ X
S✝ R✝ : Sieve X
S : Presieve X
R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → Sieve Y
f : Y ⟶ X
h : S f
Z : C
g : Z ⟶ Y
hg : (R h).arrows g
⊢ (bind S R).arrows (g ≫ f)
state_after: no goals
Theorem: nnnorm_eq_zero'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [← NNReal.coe_eq_zero, coe_nnnorm', norm_eq_zero'']
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : NormedGroup E
inst✝ : NormedGroup F
a b : E
⊢ ‖a‖₊ = 0 ↔ a = 1
state_after: no goals
Theorem: CategoryTheory.tensorLeftHomEquiv_naturality
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: simp [tensorLeftHomEquiv]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
X Y Y' Z Z' : C
inst✝ : ExactPairing Y Y'
f : Y' ⊗ X ⟶ Z
g : Z ⟶ Z'
⊢ (tensorLeftHomEquiv X Y Y' Z') (f ≫ g) = (tensorLeftHomEquiv X Y Y' Z) f ≫ Y ◁ g
state_after: no goals
Theorem: pow_le_pow_left'
File: Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean

tactic: simp
state_before: β : Type u_1
G : Type u_2
M : Type u_3
inst✝³ : Monoid M
inst✝² : Preorder M
inst✝¹ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x : M
inst✝ : CovariantClass M M (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : M
hab : a ≤ b
⊢ a ^ 0 ≤ b ^ 0
state_after: no goals

tactic: rw [pow_succ, pow_succ]
state_before: β : Type u_1
G : Type u_2
M : Type u_3
inst✝³ : Monoid M
inst✝² : Preorder M
inst✝¹ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x : M
inst✝ : CovariantClass M M (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : M
hab : a ≤ b
k : ℕ
⊢ a ^ (k + 1) ≤ b ^ (k + 1)
state_after: β : Type u_1
G : Type u_2
M : Type u_3
inst✝³ : Monoid M
inst✝² : Preorder M
inst✝¹ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x : M
inst✝ : CovariantClass M M (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : M
hab : a ≤ b
k : ℕ
⊢ a ^ k * a ≤ b ^ k * b

tactic: exact mul_le_mul' (pow_le_pow_left' hab k) hab
state_before: β : Type u_1
G : Type u_2
M : Type u_3
inst✝³ : Monoid M
inst✝² : Preorder M
inst✝¹ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x : M
inst✝ : CovariantClass M M (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : M
hab : a ≤ b
k : ℕ
⊢ a ^ k * a ≤ b ^ k * b
state_after: no goals
Theorem: Zsqrtd.ofInt_eq_intCast
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: ext <;> simp [ofInt_re, ofInt_im]
state_before: d n : ℤ
⊢ ofInt n = ↑n
state_after: no goals
Theorem: MvQPF.recF_eq'
File: Mathlib/Data/QPF/Multivariate/Constructions/Fix.lean

tactic: apply q.P.w_cases _ x
state_before: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
β : Type u
g : F (α ::: β) → β
x : (P F).W α
⊢ recF g x = g (abs ((TypeVec.id ::: recF g) <$$> (P F).wDest' x))
state_after: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
β : Type u
g : F (α ::: β) → β
x : (P F).W α
⊢ ∀ (a : (P F).A) (f' : (P F).drop.B a ⟹ α) (f : (P F).last.B a → (P F).W α),
    recF g ((P F).wMk a f' f) = g (abs ((TypeVec.id ::: recF g) <$$> (P F).wDest' ((P F).wMk a f' f)))

tactic: intro a f' f
state_before: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
β : Type u
g : F (α ::: β) → β
x : (P F).W α
⊢ ∀ (a : (P F).A) (f' : (P F).drop.B a ⟹ α) (f : (P F).last.B a → (P F).W α),
    recF g ((P F).wMk a f' f) = g (abs ((TypeVec.id ::: recF g) <$$> (P F).wDest' ((P F).wMk a f' f)))
state_after: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
β : Type u
g : F (α ::: β) → β
x : (P F).W α
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
⊢ recF g ((P F).wMk a f' f) = g (abs ((TypeVec.id ::: recF g) <$$> (P F).wDest' ((P F).wMk a f' f)))

tactic: rw [recF_eq, q.P.wDest'_wMk, MvPFunctor.map_eq, appendFun_comp_splitFun, TypeVec.id_comp]
state_before: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
β : Type u
g : F (α ::: β) → β
x : (P F).W α
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
⊢ recF g ((P F).wMk a f' f) = g (abs ((TypeVec.id ::: recF g) <$$> (P F).wDest' ((P F).wMk a f' f)))
state_after: no goals
Theorem: Order.not_isSuccLimit_iff_exists_covBy
File: Mathlib/Order/SuccPred/Limit.lean

tactic: simp [IsSuccLimit]
state_before: α : Type u_1
inst✝ : LT α
a : α
⊢ ¬IsSuccLimit a ↔ ∃ b, b ⋖ a
state_after: no goals
Theorem: spectrum.algebraMap_mem_iff
File: Mathlib/Algebra/Algebra/Spectrum.lean

tactic: simp only [spectrum.mem_iff, Algebra.algebraMap_eq_smul_one, smul_assoc, one_smul]
state_before: R✝ : Type u
A✝ : Type v
inst✝⁹ : CommSemiring R✝
inst✝⁸ : Ring A✝
inst✝⁷ : Algebra R✝ A✝
S : Type u_1
R : Type u_2
A : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : CommSemiring S
inst✝⁴ : Ring A
inst✝³ : Algebra R S
inst✝² : Algebra R A
inst✝¹ : Algebra S A
inst✝ : IsScalarTower R S A
a : A
r : R
⊢ (algebraMap R S) r ∈ spectrum S a ↔ r ∈ σ a
state_after: no goals
Theorem: Complex.abs_I
File: Mathlib/Data/Complex/Abs.lean

tactic: simp [Complex.abs]
state_before: ⊢ abs I = 1
state_after: no goals
Theorem: Finset.not_mem_union
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [mem_union, not_or]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s s₁ s₂ t t₁ t₂ u v : Finset α
a b : α
⊢ a ∉ s ∪ t ↔ a ∉ s ∧ a ∉ t
state_after: no goals
Theorem: List.DecEq_eq
File: Mathlib/Data/List/Perm.lean

tactic: funext l₁ l₂
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
inst✝ : DecidableEq α
⊢ List.beq = fun a b => decide (a = b)
state_after: case h.h
α : Type u_1
β : Type u_2
l l₁✝ l₂✝ : List α
a : α
inst✝ : DecidableEq α
l₁ l₂ : List α
⊢ l₁.beq l₂ = decide (l₁ = l₂)

tactic: show (l₁ == l₂) = _
state_before: case h.h
α : Type u_1
β : Type u_2
l l₁✝ l₂✝ : List α
a : α
inst✝ : DecidableEq α
l₁ l₂ : List α
⊢ l₁.beq l₂ = decide (l₁ = l₂)
state_after: case h.h
α : Type u_1
β : Type u_2
l l₁✝ l₂✝ : List α
a : α
inst✝ : DecidableEq α
l₁ l₂ : List α
⊢ (l₁ == l₂) = decide (l₁ = l₂)

tactic: rw [Bool.eq_iff_iff, @beq_iff_eq _ (_), decide_eq_true_iff]
state_before: case h.h
α : Type u_1
β : Type u_2
l l₁✝ l₂✝ : List α
a : α
inst✝ : DecidableEq α
l₁ l₂ : List α
⊢ (l₁ == l₂) = decide (l₁ = l₂)
state_after: no goals
Theorem: Finset.subtype_map
File: Mathlib/Data/Finset/Image.lean

tactic: ext x
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : α → Prop
inst✝ : DecidablePred p
s : Finset α
⊢ map (Embedding.subtype p) (Finset.subtype p s) = filter p s
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
p : α → Prop
inst✝ : DecidablePred p
s : Finset α
x : α
⊢ x ∈ map (Embedding.subtype p) (Finset.subtype p s) ↔ x ∈ filter p s

tactic: simp [@and_comm _ (_ = _), @and_left_comm _ (_ = _), @and_comm (p x) (x ∈ s)]
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
p : α → Prop
inst✝ : DecidablePred p
s : Finset α
x : α
⊢ x ∈ map (Embedding.subtype p) (Finset.subtype p s) ↔ x ∈ filter p s
state_after: no goals
Theorem: IsAdjoinRoot.apply_eq_lift
File: Mathlib/RingTheory/IsAdjoinRoot.lean

tactic: rw [← h.map_repr a, Polynomial.as_sum_range_C_mul_X_pow (h.repr a)]
state_before: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
g : S →+* T
hmap : ∀ (a : R), g ((algebraMap R S) a) = i a
hroot : g h.root = x
a : S
⊢ g a = (lift i x hx h) a
state_after: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
g : S →+* T
hmap : ∀ (a : R), g ((algebraMap R S) a) = i a
hroot : g h.root = x
a : S
⊢ g (h.map (∑ i ∈ Finset.range ((h.repr a).natDegree + 1), C ((h.repr a).coeff i) * X ^ i)) =
    (lift i x hx h) (h.map (∑ i ∈ Finset.range ((h.repr a).natDegree + 1), C ((h.repr a).coeff i) * X ^ i))

tactic: simp only [map_sum, map_mul, map_pow, h.map_X, hroot, ← h.algebraMap_apply, hmap, lift_root,
  lift_algebraMap]
state_before: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
g : S →+* T
hmap : ∀ (a : R), g ((algebraMap R S) a) = i a
hroot : g h.root = x
a : S
⊢ g (h.map (∑ i ∈ Finset.range ((h.repr a).natDegree + 1), C ((h.repr a).coeff i) * X ^ i)) =
    (lift i x hx h) (h.map (∑ i ∈ Finset.range ((h.repr a).natDegree + 1), C ((h.repr a).coeff i) * X ^ i))
state_after: no goals
Theorem: ArithmeticFunction.intCoe_mul
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: ext n
state_before: R : Type u_1
inst✝ : Ring R
f g : ArithmeticFunction ℤ
⊢ ↑(f * g) = ↑f * ↑g
state_after: case h
R : Type u_1
inst✝ : Ring R
f g : ArithmeticFunction ℤ
n : ℕ
⊢ ↑(f * g) n = (↑f * ↑g) n

tactic: simp
state_before: case h
R : Type u_1
inst✝ : Ring R
f g : ArithmeticFunction ℤ
n : ℕ
⊢ ↑(f * g) n = (↑f * ↑g) n
state_after: no goals
Theorem: Matroid.setOf_indep_eq
File: Mathlib/Data/Matroid/Basic.lean

tactic: simp_rw [indep_iff]
state_before: α : Type u_1
M✝ M : Matroid α
⊢ {I | M.Indep I} = ↑(lowerClosure {B | M.Base B})
state_after: α : Type u_1
M✝ M : Matroid α
⊢ {I | ∃ B, M.Base B ∧ I ⊆ B} = ↑(lowerClosure {B | M.Base B})

tactic: rfl
state_before: α : Type u_1
M✝ M : Matroid α
⊢ {I | ∃ B, M.Base B ∧ I ⊆ B} = ↑(lowerClosure {B | M.Base B})
state_after: no goals
Theorem: Polynomial.coeff_mem_coeffs
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: classical
simp only [coeffs, exists_prop, mem_support_iff, Finset.mem_image, Ne]
exact ⟨n, h, rfl⟩
state_before: R : Type u
S : Type u_1
inst✝ : Semiring R
p : R[X]
n : ℕ
h : p.coeff n ≠ 0
⊢ p.coeff n ∈ p.coeffs
state_after: no goals

tactic: simp only [coeffs, exists_prop, mem_support_iff, Finset.mem_image, Ne]
state_before: R : Type u
S : Type u_1
inst✝ : Semiring R
p : R[X]
n : ℕ
h : p.coeff n ≠ 0
⊢ p.coeff n ∈ p.coeffs
state_after: R : Type u
S : Type u_1
inst✝ : Semiring R
p : R[X]
n : ℕ
h : p.coeff n ≠ 0
⊢ ∃ a, ¬p.coeff a = 0 ∧ p.coeff a = p.coeff n

tactic: exact ⟨n, h, rfl⟩
state_before: R : Type u
S : Type u_1
inst✝ : Semiring R
p : R[X]
n : ℕ
h : p.coeff n ≠ 0
⊢ ∃ a, ¬p.coeff a = 0 ∧ p.coeff a = p.coeff n
state_after: no goals
Theorem: CategoryTheory.FunctorToTypes.binaryProductIso_inv_comp_snd
File: Mathlib/CategoryTheory/Limits/Shapes/FunctorToTypes.lean

tactic: simp [binaryProductIso, binaryProductLimitCone]
state_before: C : Type u
inst✝ : Category.{v, u} C
F G : C ⥤ Type w
⊢ (binaryProductIso F G).inv ≫ Limits.prod.snd = prod.snd
state_after: no goals
Theorem: Cardinal.self_le_power
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: α β : Type u
a b : Cardinal.{u_1}
hb : 1 ≤ b
⊢ a ≤ a ^ b
state_after: case inl
α β : Type u
b : Cardinal.{u_1}
hb : 1 ≤ b
⊢ 0 ≤ 0 ^ b

case inr
α β : Type u
a b : Cardinal.{u_1}
hb : 1 ≤ b
ha : a ≠ 0
⊢ a ≤ a ^ b

tactic: exact zero_le _
state_before: case inl
α β : Type u
b : Cardinal.{u_1}
hb : 1 ≤ b
⊢ 0 ≤ 0 ^ b
state_after: no goals

tactic: convert power_le_power_left ha hb
state_before: case inr
α β : Type u
a b : Cardinal.{u_1}
hb : 1 ≤ b
ha : a ≠ 0
⊢ a ≤ a ^ b
state_after: case h.e'_3
α β : Type u
a b : Cardinal.{u_1}
hb : 1 ≤ b
ha : a ≠ 0
⊢ a = a ^ 1

tactic: exact power_one.symm
state_before: case h.e'_3
α β : Type u
a b : Cardinal.{u_1}
hb : 1 ≤ b
ha : a ≠ 0
⊢ a = a ^ 1
state_after: no goals
Theorem: Int.two_mul
File: Mathlib/Data/Int/Defs.lean

tactic: norm_cast
state_before: a b c d m n✝ : ℤ
n : ℕ
⊢ 2 * ↑n = ↑n + ↑n
state_after: a b c d m n✝ : ℤ
n : ℕ
⊢ 2 * n = n + n

tactic: exact n.two_mul
state_before: a b c d m n✝ : ℤ
n : ℕ
⊢ 2 * n = n + n
state_after: no goals

tactic: change (2 : ℕ) * (_ : ℤ) = _
state_before: a b c d m n✝ : ℤ
n : ℕ
⊢ 2 * -[n+1] = -[n+1] + -[n+1]
state_after: a b c d m n✝ : ℤ
n : ℕ
⊢ ↑2 * -[n+1] = -[n+1] + -[n+1]

tactic: rw [Int.ofNat_mul_negSucc, Nat.two_mul, ofNat_add, Int.neg_add]
state_before: a b c d m n✝ : ℤ
n : ℕ
⊢ ↑2 * -[n+1] = -[n+1] + -[n+1]
state_after: a b c d m n✝ : ℤ
n : ℕ
⊢ -↑n.succ + -↑n.succ = -[n+1] + -[n+1]

tactic: rfl
state_before: a b c d m n✝ : ℤ
n : ℕ
⊢ -↑n.succ + -↑n.succ = -[n+1] + -[n+1]
state_after: no goals
Theorem: LowerSet.erase_sup_Iic
File: Mathlib/Order/UpperLower/Basic.lean

tactic: rw [← lowerClosure_singleton, ← sdiff_singleton, sdiff_sup_lowerClosure] <;> simpa
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : Preorder α
s : LowerSet α
t : Set α
a : α
ha : a ∈ s
has : ∀ b ∈ s, a ≤ b → b = a
⊢ s.erase a ⊔ Iic a = s
state_after: no goals
Theorem: Ideal.spanNorm_bot
File: Mathlib/RingTheory/Ideal/Norm.lean

tactic: simpa using hx
state_before: R : Type u_1
inst✝⁵ : CommRing R
S : Type u_2
inst✝⁴ : CommRing S
inst✝³ : Algebra R S
inst✝² : Nontrivial S
inst✝¹ : Module.Free R S
inst✝ : Module.Finite R S
x : R
hx : x ∈ ⇑(Algebra.norm R) '' ↑⊥
⊢ x = 0
state_after: no goals
Theorem: DFinsupp.card_Ioo
File: Mathlib/Data/DFinsupp/Interval.lean

tactic: rw [card_Ioo_eq_card_Icc_sub_two, card_Icc]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝⁴ : DecidableEq ι
inst✝³ : (i : ι) → DecidableEq (α i)
inst✝² : (i : ι) → PartialOrder (α i)
inst✝¹ : (i : ι) → Zero (α i)
inst✝ : (i : ι) → LocallyFiniteOrder (α i)
f g : Π₀ (i : ι), α i
⊢ (Ioo f g).card = ∏ i ∈ f.support ∪ g.support, (Icc (f i) (g i)).card - 2
state_after: no goals
Theorem: CategoryTheory.Limits.cospanExt_app_one
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: dsimp [cospanExt]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ (cospanExt iX iY iZ wf wg).app WalkingCospan.one = iZ
state_after: no goals
Theorem: Nat.Coprime.gcd_mul_right_cancel
File: .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean

tactic: rw [Nat.mul_comm m k, H.gcd_mul_left_cancel m]
state_before: k n m : Nat
H : k.Coprime n
⊢ (m * k).gcd n = m.gcd n
state_after: no goals
Theorem: CategoryTheory.Iso.commRingIsoToRingEquiv_toRingHom
File: Mathlib/Algebra/Category/Ring/Basic.lean

tactic: ext
state_before: X Y : CommRingCat
i : X ≅ Y
⊢ i.commRingCatIsoToRingEquiv.toRingHom = i.hom
state_after: case a
X Y : CommRingCat
i : X ≅ Y
x✝ : ↑X
⊢ i.commRingCatIsoToRingEquiv.toRingHom x✝ = i.hom x✝

tactic: rfl
state_before: case a
X Y : CommRingCat
i : X ≅ Y
x✝ : ↑X
⊢ i.commRingCatIsoToRingEquiv.toRingHom x✝ = i.hom x✝
state_after: no goals
Theorem: FirstOrder.Language.BoundedFormula.realize_foldr_sup
File: Mathlib/ModelTheory/Semantics.lean

tactic: induction' l with φ l ih
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
l : List (L.BoundedFormula α n)
v : α → M
xs : Fin n → M
⊢ (List.foldr (fun x x_1 => x ⊔ x_1) ⊥ l).Realize v xs ↔ ∃ φ ∈ l, φ.Realize v xs
state_after: case nil
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
v : α → M
xs : Fin n → M
⊢ (List.foldr (fun x x_1 => x ⊔ x_1) ⊥ []).Realize v xs ↔ ∃ φ ∈ [], φ.Realize v xs

case cons
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
v : α → M
xs : Fin n → M
φ : L.BoundedFormula α n
l : List (L.BoundedFormula α n)
ih : (List.foldr (fun x x_1 => x ⊔ x_1) ⊥ l).Realize v xs ↔ ∃ φ ∈ l, φ.Realize v xs
⊢ (List.foldr (fun x x_1 => x ⊔ x_1) ⊥ (φ :: l)).Realize v xs ↔ ∃ φ_1 ∈ φ :: l, φ_1.Realize v xs

tactic: simp
state_before: case nil
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
v : α → M
xs : Fin n → M
⊢ (List.foldr (fun x x_1 => x ⊔ x_1) ⊥ []).Realize v xs ↔ ∃ φ ∈ [], φ.Realize v xs
state_after: no goals

tactic: simp_rw [List.foldr_cons, realize_sup, ih, List.mem_cons, or_and_right, exists_or,
  exists_eq_left]
state_before: case cons
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
v : α → M
xs : Fin n → M
φ : L.BoundedFormula α n
l : List (L.BoundedFormula α n)
ih : (List.foldr (fun x x_1 => x ⊔ x_1) ⊥ l).Realize v xs ↔ ∃ φ ∈ l, φ.Realize v xs
⊢ (List.foldr (fun x x_1 => x ⊔ x_1) ⊥ (φ :: l)).Realize v xs ↔ ∃ φ_1 ∈ φ :: l, φ_1.Realize v xs
state_after: no goals
Theorem: Matrix.mul_diagonal
File: Mathlib/Data/Matrix/Basic.lean

tactic: rw [← diagonal_transpose]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : Fintype n
inst✝ : DecidableEq n
d : n → α
M : Matrix m n α
i : m
j : n
⊢ (M * diagonal d) i j = M i j * d j
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : Fintype n
inst✝ : DecidableEq n
d : n → α
M : Matrix m n α
i : m
j : n
⊢ (M * (diagonal d)ᵀ) i j = M i j * d j

tactic: apply dotProduct_diagonal
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : Fintype n
inst✝ : DecidableEq n
d : n → α
M : Matrix m n α
i : m
j : n
⊢ (M * (diagonal d)ᵀ) i j = M i j * d j
state_after: no goals
Theorem: Int.negOnePow_even
File: Mathlib/Algebra/Ring/NegOnePow.lean

tactic: obtain ⟨k, rfl⟩ := hn
state_before: n : ℤ
hn : Even n
⊢ n.negOnePow = 1
state_after: case intro
k : ℤ
⊢ (k + k).negOnePow = 1

tactic: rw [negOnePow_add, units_mul_self]
state_before: case intro
k : ℤ
⊢ (k + k).negOnePow = 1
state_after: no goals
Theorem: one_le_cfc
File: Mathlib/Topology/ContinuousFunction/FunctionalCalculus.lean

tactic: simpa using algebraMap_le_cfc f 1 a h
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹⁵ : OrderedCommSemiring R
inst✝¹⁴ : StarRing R
inst✝¹³ : StarOrderedRing R
inst✝¹² : MetricSpace R
inst✝¹¹ : TopologicalSemiring R
inst✝¹⁰ : ContinuousStar R
inst✝⁹ : ∀ (α : Type ?u.752176) [inst : TopologicalSpace α], StarOrderedRing C(α, R)
inst✝⁸ : TopologicalSpace A
inst✝⁷ : Ring A
inst✝⁶ : StarRing A
inst✝⁵ : PartialOrder A
inst✝⁴ : StarOrderedRing A
inst✝³ : Algebra R A
inst✝² : StarModule R A
inst✝¹ : ContinuousFunctionalCalculus R p
inst✝ : NonnegSpectrumClass R A
f : R → R
a : A
h : ∀ x ∈ spectrum R a, 1 ≤ f x
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
ha : autoParam (p a) _auto✝
⊢ 1 ≤ cfc f a
state_after: no goals
Theorem: Matrix.empty_vecAlt1
File: Mathlib/Data/Fin/VecNotation.lean

tactic: simp [eq_iff_true_of_subsingleton]
state_before: α✝ : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
α : Type u_4
h : 0 = 0 + 0
⊢ vecAlt1 h ![] = ![]
state_after: no goals
Theorem: BoundedVariationOn.dist_le
File: Mathlib/Analysis/BoundedVariation.lean

tactic: rw [← ENNReal.ofReal_le_ofReal_iff ENNReal.toReal_nonneg, ENNReal.ofReal_toReal h, ← edist_dist]
state_before: α : Type u_1
inst✝² : LinearOrder α
E✝ : Type u_2
inst✝¹ : PseudoEMetricSpace E✝
E : Type u_3
inst✝ : PseudoMetricSpace E
f : α → E
s : Set α
h : BoundedVariationOn f s
x y : α
hx : x ∈ s
hy : y ∈ s
⊢ dist (f x) (f y) ≤ (eVariationOn f s).toReal
state_after: α : Type u_1
inst✝² : LinearOrder α
E✝ : Type u_2
inst✝¹ : PseudoEMetricSpace E✝
E : Type u_3
inst✝ : PseudoMetricSpace E
f : α → E
s : Set α
h : BoundedVariationOn f s
x y : α
hx : x ∈ s
hy : y ∈ s
⊢ edist (f x) (f y) ≤ eVariationOn f s

tactic: exact edist_le f hx hy
state_before: α : Type u_1
inst✝² : LinearOrder α
E✝ : Type u_2
inst✝¹ : PseudoEMetricSpace E✝
E : Type u_3
inst✝ : PseudoMetricSpace E
f : α → E
s : Set α
h : BoundedVariationOn f s
x y : α
hx : x ∈ s
hy : y ∈ s
⊢ edist (f x) (f y) ≤ eVariationOn f s
state_after: no goals
Theorem: LieIdeal.comap_map_le
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rw [← map_le_iff_le_comap]
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I I₂ : LieIdeal R L
J : LieIdeal R L'
⊢ I ≤ comap f (map f I)
state_after: no goals
Theorem: Set.preimage_iterate_eq
File: Mathlib/Data/Set/Image.lean

tactic: induction' n with n ih
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
g : β → γ
f : α → α
n : ℕ
⊢ preimage f^[n] = (preimage f)^[n]
state_after: case zero
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
g : β → γ
f : α → α
⊢ preimage f^[0] = (preimage f)^[0]

case succ
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
g : β → γ
f : α → α
n : ℕ
ih : preimage f^[n] = (preimage f)^[n]
⊢ preimage f^[n + 1] = (preimage f)^[n + 1]

tactic: rw [iterate_succ, iterate_succ', preimage_comp_eq, ih]
state_before: case succ
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
g : β → γ
f : α → α
n : ℕ
ih : preimage f^[n] = (preimage f)^[n]
⊢ preimage f^[n + 1] = (preimage f)^[n + 1]
state_after: no goals

tactic: simp
state_before: case zero
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
g : β → γ
f : α → α
⊢ preimage f^[0] = (preimage f)^[0]
state_after: no goals