1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: SimpleGraph.incidenceSet_inter_incidenceSet_of_not_adj
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: simp_rw [Set.eq_empty_iff_forall_not_mem, Set.mem_inter_iff, not_and]
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
h : ¬G.Adj a b
hn : a ≠ b
⊢ G.incidenceSet a ∩ G.incidenceSet b = ∅
state_after: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
h : ¬G.Adj a b
hn : a ≠ b
⊢ ∀ x ∈ G.incidenceSet a, x ∉ G.incidenceSet b

tactic: intro u ha hb
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
h : ¬G.Adj a b
hn : a ≠ b
⊢ ∀ x ∈ G.incidenceSet a, x ∉ G.incidenceSet b
state_after: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u✝ v w : V
e : Sym2 V
h : ¬G.Adj a b
hn : a ≠ b
u : Sym2 V
ha : u ∈ G.incidenceSet a
hb : u ∈ G.incidenceSet b
⊢ False

tactic: exact h (G.adj_of_mem_incidenceSet hn ha hb)
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u✝ v w : V
e : Sym2 V
h : ¬G.Adj a b
hn : a ≠ b
u : Sym2 V
ha : u ∈ G.incidenceSet a
hb : u ∈ G.incidenceSet b
⊢ False
state_after: no goals
Theorem: SimpleGraph.Walk.IsTrail.reverse
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simpa [isTrail_def] using h
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w x y u v : V
p : G.Walk u v
h : p.IsTrail
⊢ p.reverse.IsTrail
state_after: no goals
Theorem: ack_succ_right_le_ack_succ_left
File: Mathlib/Computability/Ackermann.lean

tactic: cases' n with n n
state_before: m n : ℕ
⊢ ack m (n + 1) ≤ ack (m + 1) n
state_after: case zero
m : ℕ
⊢ ack m (0 + 1) ≤ ack (m + 1) 0

case succ
m n : ℕ
⊢ ack m (n + 1 + 1) ≤ ack (m + 1) (n + 1)

tactic: simp
state_before: case zero
m : ℕ
⊢ ack m (0 + 1) ≤ ack (m + 1) 0
state_after: no goals

tactic: rw [ack_succ_succ]
state_before: case succ
m n : ℕ
⊢ ack m (n + 1 + 1) ≤ ack (m + 1) (n + 1)
state_after: case succ
m n : ℕ
⊢ ack m (n + 1 + 1) ≤ ack m (ack (m + 1) n)

tactic: apply ack_mono_right m (le_trans _ <| add_add_one_le_ack _ n)
state_before: case succ
m n : ℕ
⊢ ack m (n + 1 + 1) ≤ ack m (ack (m + 1) n)
state_after: m n : ℕ
⊢ n + 1 + 1 ≤ m + 1 + n + 1

tactic: omega
state_before: m n : ℕ
⊢ n + 1 + 1 ≤ m + 1 + n + 1
state_after: no goals
Theorem: Finset.hasAntidiagonal_congr
File: Mathlib/Algebra/Order/Antidiag/Prod.lean

tactic: congr!
state_before: A✝ : Type u_1
A : Type u_2
inst✝ : AddMonoid A
H1 H2 : HasAntidiagonal A
⊢ antidiagonal = antidiagonal
state_after: case h.e'_3
A✝ : Type u_1
A : Type u_2
inst✝ : AddMonoid A
H1 H2 : HasAntidiagonal A
⊢ H1 = H2

tactic: apply Subsingleton.elim
state_before: case h.e'_3
A✝ : Type u_1
A : Type u_2
inst✝ : AddMonoid A
H1 H2 : HasAntidiagonal A
⊢ H1 = H2
state_after: no goals
Theorem: ENNReal.rpow_add_le_mul_rpow_add_rpow
File: Mathlib/Analysis/MeanInequalitiesPow.lean

tactic: convert rpow_arith_mean_le_arith_mean2_rpow (1 / 2) (1 / 2) (2 * z₁) (2 * z₂)
    (ENNReal.add_halves 1) hp using 1
state_before: ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0∞
p : ℝ
hp : 1 ≤ p
⊢ (z₁ + z₂) ^ p ≤ 2 ^ (p - 1) * (z₁ ^ p + z₂ ^ p)
state_after: case h.e'_3
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0∞
p : ℝ
hp : 1 ≤ p
⊢ (z₁ + z₂) ^ p = (1 / 2 * (2 * z₁) + 1 / 2 * (2 * z₂)) ^ p

case h.e'_4
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0∞
p : ℝ
hp : 1 ≤ p
⊢ 2 ^ (p - 1) * (z₁ ^ p + z₂ ^ p) = 1 / 2 * (2 * z₁) ^ p + 1 / 2 * (2 * z₂) ^ p

tactic: simp [← mul_assoc, ENNReal.inv_mul_cancel two_ne_zero two_ne_top]
state_before: case h.e'_3
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0∞
p : ℝ
hp : 1 ≤ p
⊢ (z₁ + z₂) ^ p = (1 / 2 * (2 * z₁) + 1 / 2 * (2 * z₂)) ^ p
state_after: no goals

tactic: simp only [mul_rpow_of_nonneg _ _ (zero_le_one.trans hp), rpow_sub _ _ two_ne_zero two_ne_top,
  ENNReal.div_eq_inv_mul, rpow_one, mul_one]
state_before: case h.e'_4
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0∞
p : ℝ
hp : 1 ≤ p
⊢ 2 ^ (p - 1) * (z₁ ^ p + z₂ ^ p) = 1 / 2 * (2 * z₁) ^ p + 1 / 2 * (2 * z₂) ^ p
state_after: case h.e'_4
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0∞
p : ℝ
hp : 1 ≤ p
⊢ 2⁻¹ * 2 ^ p * (z₁ ^ p + z₂ ^ p) = 2⁻¹ * (2 ^ p * z₁ ^ p) + 2⁻¹ * (2 ^ p * z₂ ^ p)

tactic: ring
state_before: case h.e'_4
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0∞
p : ℝ
hp : 1 ≤ p
⊢ 2⁻¹ * 2 ^ p * (z₁ ^ p + z₂ ^ p) = 2⁻¹ * (2 ^ p * z₁ ^ p) + 2⁻¹ * (2 ^ p * z₂ ^ p)
state_after: no goals
Theorem: Real.exists_nat_abs_mul_sub_round_le
File: Mathlib/NumberTheory/DiophantineApproximation.lean

tactic: obtain ⟨j, k, hk₀, hk₁, h⟩ := exists_int_int_abs_mul_sub_le ξ n_pos
state_before: ξ : ℝ
n : ℕ
n_pos : 0 < n
⊢ ∃ k, 0 < k ∧ k ≤ n ∧ |↑k * ξ - ↑(round (↑k * ξ))| ≤ 1 / (↑n + 1)
state_after: case intro.intro.intro.intro
ξ : ℝ
n : ℕ
n_pos : 0 < n
j k : ℤ
hk₀ : 0 < k
hk₁ : k ≤ ↑n
h : |↑k * ξ - ↑j| ≤ 1 / (↑n + 1)
⊢ ∃ k, 0 < k ∧ k ≤ n ∧ |↑k * ξ - ↑(round (↑k * ξ))| ≤ 1 / (↑n + 1)

tactic: have hk := toNat_of_nonneg hk₀.le
state_before: case intro.intro.intro.intro
ξ : ℝ
n : ℕ
n_pos : 0 < n
j k : ℤ
hk₀ : 0 < k
hk₁ : k ≤ ↑n
h : |↑k * ξ - ↑j| ≤ 1 / (↑n + 1)
⊢ ∃ k, 0 < k ∧ k ≤ n ∧ |↑k * ξ - ↑(round (↑k * ξ))| ≤ 1 / (↑n + 1)
state_after: case intro.intro.intro.intro
ξ : ℝ
n : ℕ
n_pos : 0 < n
j k : ℤ
hk₀ : 0 < k
hk₁ : k ≤ ↑n
h : |↑k * ξ - ↑j| ≤ 1 / (↑n + 1)
hk : ↑k.toNat = k
⊢ ∃ k, 0 < k ∧ k ≤ n ∧ |↑k * ξ - ↑(round (↑k * ξ))| ≤ 1 / (↑n + 1)

tactic: rw [← hk] at hk₀ hk₁ h
state_before: case intro.intro.intro.intro
ξ : ℝ
n : ℕ
n_pos : 0 < n
j k : ℤ
hk₀ : 0 < k
hk₁ : k ≤ ↑n
h : |↑k * ξ - ↑j| ≤ 1 / (↑n + 1)
hk : ↑k.toNat = k
⊢ ∃ k, 0 < k ∧ k ≤ n ∧ |↑k * ξ - ↑(round (↑k * ξ))| ≤ 1 / (↑n + 1)
state_after: case intro.intro.intro.intro
ξ : ℝ
n : ℕ
n_pos : 0 < n
j k : ℤ
hk₀ : 0 < ↑k.toNat
hk₁ : ↑k.toNat ≤ ↑n
h : |↑↑k.toNat * ξ - ↑j| ≤ 1 / (↑n + 1)
hk : ↑k.toNat = k
⊢ ∃ k, 0 < k ∧ k ≤ n ∧ |↑k * ξ - ↑(round (↑k * ξ))| ≤ 1 / (↑n + 1)

tactic: exact ⟨k.toNat, natCast_pos.mp hk₀, Nat.cast_le.mp hk₁, (round_le (↑k.toNat * ξ) j).trans h⟩
state_before: case intro.intro.intro.intro
ξ : ℝ
n : ℕ
n_pos : 0 < n
j k : ℤ
hk₀ : 0 < ↑k.toNat
hk₁ : ↑k.toNat ≤ ↑n
h : |↑↑k.toNat * ξ - ↑j| ≤ 1 / (↑n + 1)
hk : ↑k.toNat = k
⊢ ∃ k, 0 < k ∧ k ≤ n ∧ |↑k * ξ - ↑(round (↑k * ξ))| ≤ 1 / (↑n + 1)
state_after: no goals
Theorem: CategoryTheory.NatIso.inv_inv_app
File: Mathlib/CategoryTheory/NatIso.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F✝ G✝ : C ⥤ D
α : F✝ ≅ G✝
F G : C ⥤ D
e : F ≅ G
X : C
⊢ inv (e.inv.app X) = e.hom.app X
state_after: no goals
Theorem: LinearMap.range_le_ker_iff
File: Mathlib/Algebra/Module/Submodule/Range.lean

tactic: rw [← hy, ← comp_apply, h, zero_apply]
state_before: R : Type u_1
R₂ : Type u_2
R₃ : Type u_3
K : Type u_4
K₂ : Type u_5
M : Type u_6
M₂ : Type u_7
M₃ : Type u_8
V : Type u_9
V₂ : Type u_10
inst✝¹³ : Semiring R
inst✝¹² : Semiring R₂
inst✝¹¹ : Semiring R₃
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁷ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁶ : Module R M
inst✝⁵ : Module R₂ M₂
inst✝⁴ : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝³ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_11
inst✝² : FunLike F M M₂
inst✝¹ : SemilinearMapClass F τ₁₂ M M₂
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
g : M₂ →ₛₗ[τ₂₃] M₃
h : g.comp f = 0
x : M₂
hx : x ∈ range f
y : M
hy : f y = x
⊢ g x = 0
state_after: no goals
Theorem: Ordnode.Bounded.weak_left
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: cases o₂ <;> trivial
state_before: α : Type u_1
inst✝ : Preorder α
o₁ : WithBot α
o₂ : WithTop α
h : nil.Bounded o₁ o₂
⊢ nil.Bounded ⊥ o₂
state_after: no goals
Theorem: CategoryTheory.sheafify_hom_ext
File: Mathlib/CategoryTheory/Sites/Sheafification.lean

tactic: rw [sheafifyLift_unique J _ hQ _ h, ← h]
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : GrothendieckTopology C
A : Type u₂
inst✝² : Category.{v₂, u₂} A
D : Type u_1
inst✝¹ : Category.{u_2, u_1} D
inst✝ : HasWeakSheafify J D
P Q : Cᵒᵖ ⥤ D
η γ : sheafify J P ⟶ Q
hQ : Presheaf.IsSheaf J Q
h : toSheafify J P ≫ η = toSheafify J P ≫ γ
⊢ η = γ
state_after: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : GrothendieckTopology C
A : Type u₂
inst✝² : Category.{v₂, u₂} A
D : Type u_1
inst✝¹ : Category.{u_2, u_1} D
inst✝ : HasWeakSheafify J D
P Q : Cᵒᵖ ⥤ D
η γ : sheafify J P ⟶ Q
hQ : Presheaf.IsSheaf J Q
h : toSheafify J P ≫ η = toSheafify J P ≫ γ
⊢ sheafifyLift J (toSheafify J P ≫ η) hQ = γ

tactic: exact (sheafifyLift_unique J _ hQ _ h.symm).symm
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : GrothendieckTopology C
A : Type u₂
inst✝² : Category.{v₂, u₂} A
D : Type u_1
inst✝¹ : Category.{u_2, u_1} D
inst✝ : HasWeakSheafify J D
P Q : Cᵒᵖ ⥤ D
η γ : sheafify J P ⟶ Q
hQ : Presheaf.IsSheaf J Q
h : toSheafify J P ≫ η = toSheafify J P ≫ γ
⊢ sheafifyLift J (toSheafify J P ≫ η) hQ = γ
state_after: no goals
Theorem: Polynomial.dickson_one_one_eval_add_inv
File: Mathlib/RingTheory/Polynomial/Dickson.lean

tactic: simp only [eval_one, eval_add, pow_zero, dickson_zero]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a x y : R
h : x * y = 1
⊢ eval (x + y) (dickson 1 1 0) = x ^ 0 + y ^ 0
state_after: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a x y : R
h : x * y = 1
⊢ eval (x + y) (3 - ↑1) = 1 + 1

tactic: norm_num
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a x y : R
h : x * y = 1
⊢ eval (x + y) (3 - ↑1) = 1 + 1
state_after: no goals

tactic: simp only [eval_X, dickson_one, pow_one]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a x y : R
h : x * y = 1
⊢ eval (x + y) (dickson 1 1 1) = x ^ 1 + y ^ 1
state_after: no goals

tactic: simp only [eval_sub, eval_mul, dickson_one_one_eval_add_inv x y h _, eval_X, dickson_add_two,
  C_1, eval_one]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a x y : R
h : x * y = 1
n : ℕ
⊢ eval (x + y) (dickson 1 1 (n + 2)) = x ^ (n + 2) + y ^ (n + 2)
state_after: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a x y : R
h : x * y = 1
n : ℕ
⊢ (x + y) * (x ^ (n + 1) + y ^ (n + 1)) - 1 * (x ^ n + y ^ n) = x ^ (n + 2) + y ^ (n + 2)

tactic: conv_lhs => simp only [pow_succ', add_mul, mul_add, h, ← mul_assoc, mul_comm y x, one_mul]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a x y : R
h : x * y = 1
n : ℕ
⊢ (x + y) * (x ^ (n + 1) + y ^ (n + 1)) - 1 * (x ^ n + y ^ n) = x ^ (n + 2) + y ^ (n + 2)
state_after: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a x y : R
h : x * y = 1
n : ℕ
⊢ x * x * x ^ n + x ^ n + (y ^ n + y * y * y ^ n) - (x ^ n + y ^ n) = x ^ (n + 2) + y ^ (n + 2)

tactic: ring
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a x y : R
h : x * y = 1
n : ℕ
⊢ x * x * x ^ n + x ^ n + (y ^ n + y * y * y ^ n) - (x ^ n + y ^ n) = x ^ (n + 2) + y ^ (n + 2)
state_after: no goals
Theorem: ENNReal.inv_lt_top
File: Mathlib/Data/ENNReal/Inv.lean

tactic: simp only [lt_top_iff_ne_top, inv_ne_top, pos_iff_ne_zero]
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
⊢ x⁻¹ < ⊤ ↔ 0 < x
state_after: no goals
Theorem: List.rel_reverse
File: Mathlib/Data/List/Forall2.lean

tactic: simp only [reverse_cons]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
h₁ : R a✝ b✝
h₂ : Forall₂ R l₁✝ l₂✝
⊢ Forall₂ R (a✝ :: l₁✝).reverse (b✝ :: l₂✝).reverse
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
h₁ : R a✝ b✝
h₂ : Forall₂ R l₁✝ l₂✝
⊢ Forall₂ R (l₁✝.reverse ++ [a✝]) (l₂✝.reverse ++ [b✝])

tactic: exact rel_append (rel_reverse h₂) (Forall₂.cons h₁ Forall₂.nil)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
h₁ : R a✝ b✝
h₂ : Forall₂ R l₁✝ l₂✝
⊢ Forall₂ R (l₁✝.reverse ++ [a✝]) (l₂✝.reverse ++ [b✝])
state_after: no goals
Theorem: Behrend.sum_sq_le_of_mem_box
File: Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean

tactic: rw [mem_box] at hx
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hx : x ∈ box n d
⊢ ∑ i : Fin n, x i ^ 2 ≤ n * (d - 1) ^ 2
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hx : ∀ (i : Fin n), x i < d
⊢ ∑ i : Fin n, x i ^ 2 ≤ n * (d - 1) ^ 2

tactic: have : ∀ i, x i ^ 2 ≤ (d - 1) ^ 2 := fun i =>
  Nat.pow_le_pow_left (Nat.le_sub_one_of_lt (hx i)) _
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hx : ∀ (i : Fin n), x i < d
⊢ ∑ i : Fin n, x i ^ 2 ≤ n * (d - 1) ^ 2
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hx : ∀ (i : Fin n), x i < d
this : ∀ (i : Fin n), x i ^ 2 ≤ (d - 1) ^ 2
⊢ ∑ i : Fin n, x i ^ 2 ≤ n * (d - 1) ^ 2

tactic: exact (sum_le_card_nsmul univ _ _ fun i _ => this i).trans (by rw [card_fin, smul_eq_mul])
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hx : ∀ (i : Fin n), x i < d
this : ∀ (i : Fin n), x i ^ 2 ≤ (d - 1) ^ 2
⊢ ∑ i : Fin n, x i ^ 2 ≤ n * (d - 1) ^ 2
state_after: no goals

tactic: rw [card_fin, smul_eq_mul]
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hx : ∀ (i : Fin n), x i < d
this : ∀ (i : Fin n), x i ^ 2 ≤ (d - 1) ^ 2
⊢ univ.card • (d - 1) ^ 2 ≤ n * (d - 1) ^ 2
state_after: no goals
Theorem: LinearMap.toMatrix₂_basisFun
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

tactic: ext B
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
M : Type u_4
M₁ : Type u_5
M₂ : Type u_6
M₁' : Type u_7
M₂' : Type u_8
n : Type u_9
m : Type u_10
n' : Type u_11
m' : Type u_12
ι : Type u_13
inst✝⁸ : CommSemiring R
inst✝⁷ : AddCommMonoid M₁
inst✝⁶ : Module R M₁
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₂
inst✝³ : DecidableEq n
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : Fintype m
b₁ : Basis n R M₁
b₂ : Basis m R M₂
⊢ toMatrix₂ (Pi.basisFun R n) (Pi.basisFun R m) = toMatrix₂'
state_after: case h.a
R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
M : Type u_4
M₁ : Type u_5
M₂ : Type u_6
M₁' : Type u_7
M₂' : Type u_8
n : Type u_9
m : Type u_10
n' : Type u_11
m' : Type u_12
ι : Type u_13
inst✝⁸ : CommSemiring R
inst✝⁷ : AddCommMonoid M₁
inst✝⁶ : Module R M₁
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₂
inst✝³ : DecidableEq n
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : Fintype m
b₁ : Basis n R M₁
b₂ : Basis m R M₂
B : (n → R) →ₗ[R] (m → R) →ₗ[R] R
i✝ : n
j✝ : m
⊢ (toMatrix₂ (Pi.basisFun R n) (Pi.basisFun R m)) B i✝ j✝ = toMatrix₂' B i✝ j✝

tactic: rw [LinearMap.toMatrix₂_apply, LinearMap.toMatrix₂'_apply, Pi.basisFun_apply, Pi.basisFun_apply]
state_before: case h.a
R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
M : Type u_4
M₁ : Type u_5
M₂ : Type u_6
M₁' : Type u_7
M₂' : Type u_8
n : Type u_9
m : Type u_10
n' : Type u_11
m' : Type u_12
ι : Type u_13
inst✝⁸ : CommSemiring R
inst✝⁷ : AddCommMonoid M₁
inst✝⁶ : Module R M₁
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₂
inst✝³ : DecidableEq n
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : Fintype m
b₁ : Basis n R M₁
b₂ : Basis m R M₂
B : (n → R) →ₗ[R] (m → R) →ₗ[R] R
i✝ : n
j✝ : m
⊢ (toMatrix₂ (Pi.basisFun R n) (Pi.basisFun R m)) B i✝ j✝ = toMatrix₂' B i✝ j✝
state_after: no goals
Theorem: mul_le_of_one_le_right
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: simpa only [mul_one] using mul_le_mul_of_nonpos_left h ha
state_before: α : Type u
β : Type u_1
inst✝² : OrderedSemiring α
a b c d : α
inst✝¹ : ExistsAddOfLE α
inst✝ : ContravariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
ha : a ≤ 0
h : 1 ≤ b
⊢ a * b ≤ a
state_after: no goals
Theorem: Bornology.isVonNBounded_iUnion
File: Mathlib/Analysis/LocallyConvex/Bounded.lean

tactic: simp only [IsVonNBounded, absorbs_iUnion, @forall_swap ι]
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
E : Type u_3
E' : Type u_4
F : Type u_5
ι✝ : Type u_6
inst✝⁴ : SeminormedRing 𝕜
inst✝³ : SMul 𝕜 E
inst✝² : Zero E
inst✝¹ : TopologicalSpace E
ι : Sort u_7
inst✝ : Finite ι
s : ι → Set E
⊢ IsVonNBounded 𝕜 (⋃ i, s i) ↔ ∀ (i : ι), IsVonNBounded 𝕜 (s i)
state_after: no goals
Theorem: ProbabilityTheory.kernel.setIntegral_piecewise
File: Mathlib/Probability/Kernel/Basic.lean

tactic: simp_rw [piecewise_apply]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ η : ↥(kernel α β)
s : Set α
hs : MeasurableSet s
inst✝² : DecidablePred fun x => x ∈ s
E : Type u_4
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
a : α
g : β → E
t : Set β
⊢ ∫ (b : β) in t, g b ∂(piecewise hs κ η) a = if a ∈ s then ∫ (b : β) in t, g b ∂κ a else ∫ (b : β) in t, g b ∂η a
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ η : ↥(kernel α β)
s : Set α
hs : MeasurableSet s
inst✝² : DecidablePred fun x => x ∈ s
E : Type u_4
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
a : α
g : β → E
t : Set β
⊢ (∫ (b : β) in t, g b ∂if a ∈ s then κ a else η a) =
    if a ∈ s then ∫ (b : β) in t, g b ∂κ a else ∫ (b : β) in t, g b ∂η a

tactic: split_ifs <;> rfl
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ η : ↥(kernel α β)
s : Set α
hs : MeasurableSet s
inst✝² : DecidablePred fun x => x ∈ s
E : Type u_4
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
a : α
g : β → E
t : Set β
⊢ (∫ (b : β) in t, g b ∂if a ∈ s then κ a else η a) =
    if a ∈ s then ∫ (b : β) in t, g b ∂κ a else ∫ (b : β) in t, g b ∂η a
state_after: no goals
Theorem: Nat.ModEq.add_left_cancel
File: Mathlib/Data/Nat/ModEq.lean

tactic: simp only [modEq_iff_dvd, Int.ofNat_add] at *
state_before: m n a b c d : ℕ
h₁ : a ≡ b [MOD n]
h₂ : a + c ≡ b + d [MOD n]
⊢ c ≡ d [MOD n]
state_after: m n a b c d : ℕ
h₁ : ↑n ∣ ↑b - ↑a
h₂ : ↑n ∣ ↑b + ↑d - (↑a + ↑c)
⊢ ↑n ∣ ↑d - ↑c

tactic: rw [add_sub_add_comm] at h₂
state_before: m n a b c d : ℕ
h₁ : ↑n ∣ ↑b - ↑a
h₂ : ↑n ∣ ↑b + ↑d - (↑a + ↑c)
⊢ ↑n ∣ ↑d - ↑c
state_after: m n a b c d : ℕ
h₁ : ↑n ∣ ↑b - ↑a
h₂ : ↑n ∣ ↑b - ↑a + (↑d - ↑c)
⊢ ↑n ∣ ↑d - ↑c

tactic: convert _root_.dvd_sub h₂ h₁ using 1
state_before: m n a b c d : ℕ
h₁ : ↑n ∣ ↑b - ↑a
h₂ : ↑n ∣ ↑b - ↑a + (↑d - ↑c)
⊢ ↑n ∣ ↑d - ↑c
state_after: case h.e'_4
m n a b c d : ℕ
h₁ : ↑n ∣ ↑b - ↑a
h₂ : ↑n ∣ ↑b - ↑a + (↑d - ↑c)
⊢ ↑d - ↑c = ↑b - ↑a + (↑d - ↑c) - (↑b - ↑a)

tactic: rw [add_sub_cancel_left]
state_before: case h.e'_4
m n a b c d : ℕ
h₁ : ↑n ∣ ↑b - ↑a
h₂ : ↑n ∣ ↑b - ↑a + (↑d - ↑c)
⊢ ↑d - ↑c = ↑b - ↑a + (↑d - ↑c) - (↑b - ↑a)
state_after: no goals
Theorem: Order.Ideal.IsPrime.mem_or_mem
File: Mathlib/Order/PrimeIdeal.lean

tactic: contrapose!
state_before: P : Type u_1
inst✝ : SemilatticeInf P
x✝ y✝ : P
I : Ideal P
hI : I.IsPrime
x y : P
⊢ x ⊓ y ∈ I → x ∈ I ∨ y ∈ I
state_after: P : Type u_1
inst✝ : SemilatticeInf P
x✝ y✝ : P
I : Ideal P
hI : I.IsPrime
x y : P
⊢ x ∉ I ∧ y ∉ I → x ⊓ y ∉ I

tactic: let F := hI.compl_filter.toPFilter
state_before: P : Type u_1
inst✝ : SemilatticeInf P
x✝ y✝ : P
I : Ideal P
hI : I.IsPrime
x y : P
⊢ x ∉ I ∧ y ∉ I → x ⊓ y ∉ I
state_after: P : Type u_1
inst✝ : SemilatticeInf P
x✝ y✝ : P
I : Ideal P
hI : I.IsPrime
x y : P
F : PFilter P := ⋯.toPFilter
⊢ x ∉ I ∧ y ∉ I → x ⊓ y ∉ I

tactic: show x ∈ F ∧ y ∈ F → x ⊓ y ∈ F
state_before: P : Type u_1
inst✝ : SemilatticeInf P
x✝ y✝ : P
I : Ideal P
hI : I.IsPrime
x y : P
F : PFilter P := ⋯.toPFilter
⊢ x ∉ I ∧ y ∉ I → x ⊓ y ∉ I
state_after: P : Type u_1
inst✝ : SemilatticeInf P
x✝ y✝ : P
I : Ideal P
hI : I.IsPrime
x y : P
F : PFilter P := ⋯.toPFilter
⊢ x ∈ F ∧ y ∈ F → x ⊓ y ∈ F

tactic: exact fun h => inf_mem h.1 h.2
state_before: P : Type u_1
inst✝ : SemilatticeInf P
x✝ y✝ : P
I : Ideal P
hI : I.IsPrime
x y : P
F : PFilter P := ⋯.toPFilter
⊢ x ∈ F ∧ y ∈ F → x ⊓ y ∈ F
state_after: no goals
Theorem: Matrix.trace_mul_cycle
File: Mathlib/LinearAlgebra/Matrix/Trace.lean

tactic: rw [trace_mul_comm, Matrix.mul_assoc]
state_before: ι : Type u_1
m : Type u_2
n : Type u_3
p : Type u_4
α : Type u_5
R : Type u_6
S : Type u_7
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : Fintype p
inst✝ : NonUnitalCommSemiring R
A : Matrix m n R
B : Matrix n p R
C : Matrix p m R
⊢ (A * B * C).trace = (C * A * B).trace
state_after: no goals
Theorem: NonUnitalStarSubalgebra.toNonUnitalSubalgebra_injective
File: Mathlib/Algebra/Star/NonUnitalSubalgebra.lean

tactic: rw [← mem_toNonUnitalSubalgebra, ← mem_toNonUnitalSubalgebra, h]
state_before: F : Type v'
R' : Type u'
R : Type u
A : Type v
B : Type w
C : Type w'
inst✝¹² : CommSemiring R
inst✝¹¹ : NonUnitalNonAssocSemiring A
inst✝¹⁰ : Module R A
inst✝⁹ : Star A
inst✝⁸ : NonUnitalNonAssocSemiring B
inst✝⁷ : Module R B
inst✝⁶ : Star B
inst✝⁵ : NonUnitalNonAssocSemiring C
inst✝⁴ : Module R C
inst✝³ : Star C
inst✝² : FunLike F A B
inst✝¹ : NonUnitalAlgHomClass F R A B
inst✝ : NonUnitalStarAlgHomClass F R A B
S T : NonUnitalStarSubalgebra R A
h : S.toNonUnitalSubalgebra = T.toNonUnitalSubalgebra
x : A
⊢ x ∈ S ↔ x ∈ T
state_after: no goals
Theorem: FirstOrder.Language.Structure.FG.map_of_surjective
File: Mathlib/ModelTheory/FinitelyGenerated.lean

tactic: rw [← Hom.range_eq_top] at hs
state_before: L : Language
M : Type u_1
inst✝¹ : L.Structure M
N : Type u_2
inst✝ : L.Structure N
h : FG L M
f : M →[L] N
hs : Function.Surjective ⇑f
⊢ FG L N
state_after: L : Language
M : Type u_1
inst✝¹ : L.Structure M
N : Type u_2
inst✝ : L.Structure N
h : FG L M
f : M →[L] N
hs : f.range = ⊤
⊢ FG L N

tactic: rw [fg_def, ← hs]
state_before: L : Language
M : Type u_1
inst✝¹ : L.Structure M
N : Type u_2
inst✝ : L.Structure N
h : FG L M
f : M →[L] N
hs : f.range = ⊤
⊢ FG L N
state_after: L : Language
M : Type u_1
inst✝¹ : L.Structure M
N : Type u_2
inst✝ : L.Structure N
h : FG L M
f : M →[L] N
hs : f.range = ⊤
⊢ f.range.FG

tactic: exact h.range f
state_before: L : Language
M : Type u_1
inst✝¹ : L.Structure M
N : Type u_2
inst✝ : L.Structure N
h : FG L M
f : M →[L] N
hs : f.range = ⊤
⊢ f.range.FG
state_after: no goals
Theorem: finprod_mem_eq_prod
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: simp [inter_assoc]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
s : Set α
hf : (s ∩ mulSupport f).Finite
⊢ s ∩ mulSupport f = ↑hf.toFinset ∩ mulSupport f
state_after: no goals
Theorem: List.mem_eraseIdx_iff_get?
File: .lake/packages/batteries/Batteries/Data/List/EraseIdx.lean

tactic: simp [mem_eraseIdx_iff_getElem?]
state_before: α : Type u
β : Type v
x : α
l : List α
k : Nat
⊢ x ∈ l.eraseIdx k ↔ ∃ i, i ≠ k ∧ l.get? i = some x
state_after: no goals
Theorem: NNReal.summable_nat_add_iff
File: Mathlib/Topology/Instances/NNReal.lean

tactic: rw [← summable_coe, ← summable_coe]
state_before: α : Type u_1
f : ℕ → ℝ≥0
k : ℕ
⊢ (Summable fun i => f (i + k)) ↔ Summable f
state_after: α : Type u_1
f : ℕ → ℝ≥0
k : ℕ
⊢ (Summable fun a => ↑(f (a + k))) ↔ Summable fun a => ↑(f a)

tactic: exact @summable_nat_add_iff ℝ _ _ _ (fun i => (f i : ℝ)) k
state_before: α : Type u_1
f : ℕ → ℝ≥0
k : ℕ
⊢ (Summable fun a => ↑(f (a + k))) ↔ Summable fun a => ↑(f a)
state_after: no goals