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

tactic: rw [G.edgeFinset_sup_edge hn h, card_cons]
state_before: V : Type u_1
inst✝³ : DecidableEq V
G : SimpleGraph V
s t : V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Fintype ↑(G ⊔ edge s t).edgeSet
hn : ¬G.Adj s t
h : s ≠ t
⊢ (G ⊔ edge s t).edgeFinset.card = G.edgeFinset.card + 1
state_after: no goals
Theorem: WeierstrassCurve.Ψ_three
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

tactic: erw [Ψ_ofNat, preΨ'_three, mul_one]
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
⊢ W.Ψ 3 = C W.Ψ₃
state_after: no goals
Theorem: Finset.mem_shadow_iff
File: Mathlib/Combinatorics/SetFamily/Shadow.lean

tactic: simp only [shadow, mem_sup, mem_image]
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ t ∈ ∂ 𝒜 ↔ ∃ s ∈ 𝒜, ∃ a ∈ s, s.erase a = t
state_after: no goals
Theorem: SimpleGraph.Walk.IsTrail.of_cons
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp [isTrail_def]
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 w : V
h : G.Adj u v
p : G.Walk v w
⊢ (cons h p).IsTrail → p.IsTrail
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.neg_smul
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: rw [neg, negY_smul]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
u : R
⊢ W'.neg (u • P) = u • W'.neg P
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
u : R
⊢ ![(u • P) x, u ^ 3 * W'.negY P, (u • P) z] = u • W'.neg P

tactic: rfl
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
u : R
⊢ ![(u • P) x, u ^ 3 * W'.negY P, (u • P) z] = u • W'.neg P
state_after: no goals
Theorem: IsCompact.disjoint_nhdsSet_right
File: Mathlib/Topology/Compactness/Compact.lean

tactic: simpa only [disjoint_comm] using hs.disjoint_nhdsSet_left
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
l : Filter X
hs : IsCompact s
⊢ Disjoint l (𝓝ˢ s) ↔ ∀ x ∈ s, Disjoint l (𝓝 x)
state_after: no goals
Theorem: Finset.neg_smul
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp_rw [← image_neg]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁴ : Ring α
inst✝³ : AddCommGroup β
inst✝² : Module α β
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
a : α
inst✝ : DecidableEq α
⊢ -s • t = -(s • t)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁴ : Ring α
inst✝³ : AddCommGroup β
inst✝² : Module α β
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
a : α
inst✝ : DecidableEq α
⊢ image (fun x => -x) s • t = image (fun x => -x) (s • t)

tactic: exact image₂_image_left_comm neg_smul
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁴ : Ring α
inst✝³ : AddCommGroup β
inst✝² : Module α β
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
a : α
inst✝ : DecidableEq α
⊢ image (fun x => -x) s • t = image (fun x => -x) (s • t)
state_after: no goals
Theorem: one_sub_invOf_two
File: Mathlib/Algebra/Ring/Invertible.lean

tactic: rw [mul_sub, mul_invOf_self, mul_one, ← one_add_one_eq_two, add_sub_cancel_right]
state_before: α : Type u
inst✝¹ : Ring α
inst✝ : Invertible 2
⊢ 2 * (1 - ⅟2) = 2 * ⅟2
state_after: no goals
Theorem: MeasureTheory.SimpleFunc.setToSimpleFunc_zero
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: simp [setToSimpleFunc]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m✝ : MeasurableSpace α
μ : Measure α
m : MeasurableSpace α
f : α →ₛ F
⊢ setToSimpleFunc 0 f = 0
state_after: no goals
Theorem: List.indexesOf_cons
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: simp [indexesOf, findIdxs_cons]
state_before: α : Type u_1
x : α
xs : List α
y : α
inst✝ : BEq α
⊢ indexesOf y (x :: xs) =
    bif x == y then 0 :: map (fun x => x + 1) (indexesOf y xs) else map (fun x => x + 1) (indexesOf y xs)
state_after: no goals
Theorem: LinearMap.separatingLeft_iff_det_ne_zero
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

tactic: rw [← Matrix.nondegenerate_iff_det_ne_zero, nondegenerate_toMatrix_iff]
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✝⁵ : CommRing R₁
inst✝⁴ : AddCommMonoid M₁
inst✝³ : Module R₁ M₁
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
B✝ : M₁ →ₗ[R₁] M₁ →ₗ[R₁] R₁
inst✝ : IsDomain R₁
B : M₁ →ₗ[R₁] M₁ →ₗ[R₁] R₁
b : Basis ι R₁ M₁
⊢ B.SeparatingLeft ↔ ((toMatrix₂ b b) B).det ≠ 0
state_after: no goals
Theorem: Matrix.star_dotProduct_star
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp [dotProduct]
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✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : NonUnitalSemiring α
inst✝ : StarRing α
v w : m → α
⊢ star v ⬝ᵥ star w = star (w ⬝ᵥ v)
state_after: no goals
Theorem: SignType.lt_one_iff
File: Mathlib/Data/Sign.lean

tactic: cases a <;> decide
state_before: a : SignType
⊢ a < 1 ↔ a ≤ 0
state_after: no goals
Theorem: LinearMap.BilinForm.IsAdjointPair.add
File: Mathlib/LinearAlgebra/BilinearForm/Properties.lean

tactic: rw [LinearMap.add_apply, LinearMap.add_apply, add_left, add_right, h, h']
state_before: R : Type u_1
M : Type u_2
inst✝¹⁴ : CommSemiring R
inst✝¹³ : AddCommMonoid M
inst✝¹² : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝¹¹ : CommRing R₁
inst✝¹⁰ : AddCommGroup M₁
inst✝⁹ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁸ : Field K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
M'✝ : Type u_7
M'' : Type u_8
inst✝⁵ : AddCommMonoid M'✝
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M'✝
inst✝² : Module R M''
B : BilinForm R M
B₁ : BilinForm R₁ M₁
F : BilinForm R M
M' : Type u_9
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
B' : BilinForm R M'
f f' : M →ₗ[R] M'
g g' : M' →ₗ[R] M
h : B.IsAdjointPair B' f g
h' : B.IsAdjointPair B' f' g'
x : M
y : M'
⊢ (B' ((f + f') x)) y = (B x) ((g + g') y)
state_after: no goals
Theorem: Set.Iic_mul_Iic_subset'
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: rintro x ⟨y, hya, z, hzb, rfl⟩
state_before: α : Type u_1
inst✝³ : Mul α
inst✝² : Preorder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LE.le
a b : α
⊢ Iic a * Iic b ⊆ Iic (a * b)
state_after: case intro.intro.intro.intro
α : Type u_1
inst✝³ : Mul α
inst✝² : Preorder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LE.le
a b y : α
hya : y ∈ Iic a
z : α
hzb : z ∈ Iic b
⊢ (fun x x_1 => x * x_1) y z ∈ Iic (a * b)

tactic: exact mul_le_mul' hya hzb
state_before: case intro.intro.intro.intro
α : Type u_1
inst✝³ : Mul α
inst✝² : Preorder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LE.le
a b y : α
hya : y ∈ Iic a
z : α
hzb : z ∈ Iic b
⊢ (fun x x_1 => x * x_1) y z ∈ Iic (a * b)
state_after: no goals
Theorem: CategoryTheory.Subobject.le_mk_of_comm
File: Mathlib/CategoryTheory/Subobject/Basic.lean

tactic: simp [w]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X✝ Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
B A : C
X : Subobject B
f : A ⟶ B
inst✝ : Mono f
g : underlying.obj X ⟶ A
w : g ≫ f = X.arrow
⊢ (g ≫ (underlyingIso f).inv) ≫ (mk f).arrow = X.arrow
state_after: no goals
Theorem: Subgroup.orderOf_dvd_natCard
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: simpa using orderOf_dvd_natCard (⟨x, hx⟩ : s)
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Fintype G
x : G
n : ℕ
s : Subgroup G
hx : x ∈ s
⊢ orderOf x ∣ Nat.card ↥s
state_after: no goals
Theorem: Zsqrtd.nonnegg_neg_pos
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: simp [SqLe, Nat.zero_le]
state_before: d✝ : ℤ
c d b : ℕ
⊢ Nonnegg c d (-↑0) ↑b → SqLe 0 d b c
state_after: no goals

tactic: rw [← Int.negSucc_coe]
state_before: d✝ : ℤ
c d a b : ℕ
⊢ Nonnegg c d (-↑(a + 1)) ↑b ↔ SqLe (a + 1) d b c
state_after: d✝ : ℤ
c d a b : ℕ
⊢ Nonnegg c d (Int.negSucc a) ↑b ↔ SqLe (a + 1) d b c

tactic: rfl
state_before: d✝ : ℤ
c d a b : ℕ
⊢ Nonnegg c d (Int.negSucc a) ↑b ↔ SqLe (a + 1) d b c
state_after: no goals
Theorem: HasStrictFDerivAt.mem_implicitToPartialHomeomorphOfComplemented_target
File: Mathlib/Analysis/Calculus/Implicit.lean

tactic: simpa only [implicitToPartialHomeomorphOfComplemented_self] using
  (hf.implicitToPartialHomeomorphOfComplemented f f' hf' hker).map_source <|
    hf.mem_implicitToPartialHomeomorphOfComplemented_source hf' hker
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : CompleteSpace E
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
f : E → F
f' : E →L[𝕜] F
a : E
hf : HasStrictFDerivAt f f' a
hf' : range f' = ⊤
hker : (LinearMap.ker f').ClosedComplemented
⊢ (f a, 0) ∈ (implicitToPartialHomeomorphOfComplemented f f' hf hf' hker).target
state_after: no goals
Theorem: Filter.ker_pure
File: Mathlib/Order/Filter/Ker.lean

tactic: rw [← principal_singleton, ker_principal]
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
f g : Filter α
s : Set α
a✝ a : α
⊢ (pure a).ker = {a}
state_after: no goals
Theorem: DFinsupp.sumAddHom_single
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: dsimp [sumAddHom, single, Trunc.lift_mk]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → AddZeroClass (β i)
inst✝ : AddCommMonoid γ
φ : (i : ι) → β i →+ γ
i : ι
x : β i
⊢ (sumAddHom φ) (single i x) = (φ i) x
state_after: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → AddZeroClass (β i)
inst✝ : AddCommMonoid γ
φ : (i : ι) → β i →+ γ
i : ι
x : β i
⊢ ∑ i_1 ∈ {i}.toFinset, (φ i_1) (Pi.single i x i_1) = (φ i) x

tactic: rw [Multiset.toFinset_singleton, Finset.sum_singleton, Pi.single_eq_same]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → AddZeroClass (β i)
inst✝ : AddCommMonoid γ
φ : (i : ι) → β i →+ γ
i : ι
x : β i
⊢ ∑ i_1 ∈ {i}.toFinset, (φ i_1) (Pi.single i x i_1) = (φ i) x
state_after: no goals
Theorem: tangentCone_mono
File: Mathlib/Analysis/Calculus/TangentCone.lean

tactic: rintro y ⟨c, d, ds, ctop, clim⟩
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
h : s ⊆ t
⊢ tangentConeAt 𝕜 s x ⊆ tangentConeAt 𝕜 t x
state_after: case intro.intro.intro.intro
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y✝ : E
s t : Set E
h : s ⊆ t
y : E
c : ℕ → 𝕜
d : ℕ → E
ds : ∀ᶠ (n : ℕ) in atTop, x + d n ∈ s
ctop : Tendsto (fun n => ‖c n‖) atTop atTop
clim : Tendsto (fun n => c n • d n) atTop (𝓝 y)
⊢ y ∈ tangentConeAt 𝕜 t x

tactic: exact ⟨c, d, mem_of_superset ds fun n hn => h hn, ctop, clim⟩
state_before: case intro.intro.intro.intro
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y✝ : E
s t : Set E
h : s ⊆ t
y : E
c : ℕ → 𝕜
d : ℕ → E
ds : ∀ᶠ (n : ℕ) in atTop, x + d n ∈ s
ctop : Tendsto (fun n => ‖c n‖) atTop atTop
clim : Tendsto (fun n => c n • d n) atTop (𝓝 y)
⊢ y ∈ tangentConeAt 𝕜 t x
state_after: no goals
Theorem: Polynomial.isUnit_C_add_X_mul_iff
File: Mathlib/RingTheory/Polynomial/Nilpotent.lean

tactic: have : ∀ i, coeff (C r + X * P) (i + 1) = coeff P i := by simp
state_before: R : Type u_1
r : R
inst✝ : CommRing R
P : R[X]
⊢ IsUnit (C r + X * P) ↔ IsUnit r ∧ IsNilpotent P
state_after: R : Type u_1
r : R
inst✝ : CommRing R
P : R[X]
this : ∀ (i : ℕ), (C r + X * P).coeff (i + 1) = P.coeff i
⊢ IsUnit (C r + X * P) ↔ IsUnit r ∧ IsNilpotent P

tactic: simp_rw [isUnit_iff_coeff_isUnit_isNilpotent, Nat.forall_ne_zero_iff, this]
state_before: R : Type u_1
r : R
inst✝ : CommRing R
P : R[X]
this : ∀ (i : ℕ), (C r + X * P).coeff (i + 1) = P.coeff i
⊢ IsUnit (C r + X * P) ↔ IsUnit r ∧ IsNilpotent P
state_after: R : Type u_1
r : R
inst✝ : CommRing R
P : R[X]
this : ∀ (i : ℕ), (C r + X * P).coeff (i + 1) = P.coeff i
⊢ (IsUnit ((C r + X * P).coeff 0) ∧ ∀ (i : ℕ), IsNilpotent (P.coeff i)) ↔ IsUnit r ∧ IsNilpotent P

tactic: simp only [coeff_add, coeff_C_zero, mul_coeff_zero, coeff_X_zero, zero_mul, add_zero,
  and_congr_right_iff, ← Polynomial.isNilpotent_iff]
state_before: R : Type u_1
r : R
inst✝ : CommRing R
P : R[X]
this : ∀ (i : ℕ), (C r + X * P).coeff (i + 1) = P.coeff i
⊢ (IsUnit ((C r + X * P).coeff 0) ∧ ∀ (i : ℕ), IsNilpotent (P.coeff i)) ↔ IsUnit r ∧ IsNilpotent P
state_after: no goals

tactic: simp
state_before: R : Type u_1
r : R
inst✝ : CommRing R
P : R[X]
⊢ ∀ (i : ℕ), (C r + X * P).coeff (i + 1) = P.coeff i
state_after: no goals
Theorem: Fintype.prod_unique
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: rw [univ_unique, prod_singleton]
state_before: ι✝ : Type u_1
κ✝ : Type u_2
α✝¹ : Type u_3
β✝ : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α✝¹
a : α✝¹
f✝ g : α✝¹ → β✝
ι : Type u_6
κ : Type u_7
α✝ : Type u_8
inst✝⁵ : Fintype ι
inst✝⁴ : Fintype κ
inst✝³ : CommMonoid α✝
α : Type u_9
β : Type u_10
inst✝² : CommMonoid β
inst✝¹ : Unique α
inst✝ : Fintype α
f : α → β
⊢ ∏ x : α, f x = f default
state_after: no goals
Theorem: Real.b_ne_one
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: linarith
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
⊢ b ≠ 1
state_after: no goals
Theorem: Algebra.Presentation.ideal_fg_of_isFinite
File: Mathlib/RingTheory/Presentation.lean

tactic: use (Set.finite_range P.relation).toFinset
state_before: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Algebra R S
P : Presentation R S
inst✝ : P.IsFinite
⊢ P.ker.FG
state_after: case h
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Algebra R S
P : Presentation R S
inst✝ : P.IsFinite
⊢ Ideal.span ↑⋯.toFinset = P.ker

tactic: simp [span_range_relation_eq_ker]
state_before: case h
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Algebra R S
P : Presentation R S
inst✝ : P.IsFinite
⊢ Ideal.span ↑⋯.toFinset = P.ker
state_after: no goals
Theorem: CategoryTheory.InjectiveResolution.desc_commutes
File: Mathlib/CategoryTheory/Abelian/InjectiveResolution.lean

tactic: ext
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
Y Z : C
f : Z ⟶ Y
I : InjectiveResolution Y
J : InjectiveResolution Z
⊢ J.ι ≫ desc f I J = (CochainComplex.single₀ C).map f ≫ I.ι
state_after: case hfg
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
Y Z : C
f : Z ⟶ Y
I : InjectiveResolution Y
J : InjectiveResolution Z
⊢ (J.ι ≫ desc f I J).f 0 = ((CochainComplex.single₀ C).map f ≫ I.ι).f 0

tactic: simp [desc, descFOne, descFZero]
state_before: case hfg
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
Y Z : C
f : Z ⟶ Y
I : InjectiveResolution Y
J : InjectiveResolution Z
⊢ (J.ι ≫ desc f I J).f 0 = ((CochainComplex.single₀ C).map f ≫ I.ι).f 0
state_after: no goals
Theorem: toIcoMod_add_toIocMod_zero
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [toIcoMod_zero_sub_comm, sub_add_cancel]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoMod hp 0 (a - b) + toIocMod hp 0 (b - a) = p
state_after: no goals
Theorem: Fin.foldl_rev
File: .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean

tactic: induction n generalizing x with
| zero => simp
| succ n ih => rw [foldl_succ, foldr_succ_last, ← ih]; simp [rev_succ]
state_before: n : Nat
α : Sort u_1
f : Fin n → α → α
x : α
⊢ foldl n (fun x i => f i.rev x) x = foldr n f x
state_after: no goals

tactic: simp
state_before: case zero
α : Sort u_1
f : Fin 0 → α → α
x : α
⊢ foldl 0 (fun x i => f i.rev x) x = foldr 0 f x
state_after: no goals

tactic: rw [foldl_succ, foldr_succ_last, ← ih]
state_before: case succ
α : Sort u_1
n : Nat
ih : ∀ (f : Fin n → α → α) (x : α), foldl n (fun x i => f i.rev x) x = foldr n f x
f : Fin (n + 1) → α → α
x : α
⊢ foldl (n + 1) (fun x i => f i.rev x) x = foldr (n + 1) f x
state_after: case succ
α : Sort u_1
n : Nat
ih : ∀ (f : Fin n → α → α) (x : α), foldl n (fun x i => f i.rev x) x = foldr n f x
f : Fin (n + 1) → α → α
x : α
⊢ foldl n (fun x i => f i.succ.rev x) (f (rev 0) x) = foldl n (fun x i => f i.rev.castSucc x) (f (last n) x)

tactic: simp [rev_succ]
state_before: case succ
α : Sort u_1
n : Nat
ih : ∀ (f : Fin n → α → α) (x : α), foldl n (fun x i => f i.rev x) x = foldr n f x
f : Fin (n + 1) → α → α
x : α
⊢ foldl n (fun x i => f i.succ.rev x) (f (rev 0) x) = foldl n (fun x i => f i.rev.castSucc x) (f (last n) x)
state_after: no goals
Theorem: Real.fourierIntegralInv_eq_fourierIntegral_neg
File: Mathlib/Analysis/Fourier/FourierTransform.lean

tactic: simp [fourierIntegral_eq, fourierIntegralInv_eq]
state_before: E : Type u_1
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace ℂ E
V : Type u_2
inst✝⁹ : NormedAddCommGroup V
inst✝⁸ : InnerProductSpace ℝ V
inst✝⁷ : MeasurableSpace V
inst✝⁶ : BorelSpace V
inst✝⁵ : FiniteDimensional ℝ V
W : Type u_3
inst✝⁴ : NormedAddCommGroup W
inst✝³ : InnerProductSpace ℝ W
inst✝² : MeasurableSpace W
inst✝¹ : BorelSpace W
inst✝ : FiniteDimensional ℝ W
f : V → E
w : V
⊢ 𝓕⁻ f w = 𝓕 f (-w)
state_after: no goals
Theorem: Finset.mem_finAntidiagonal₀
File: Mathlib/Algebra/Order/Antidiag/Finsupp.lean

tactic: rw [mem_finAntidiagonal₀', sum_of_support_subset f (subset_univ _) _ (fun _ _ => rfl)]
state_before: ι : Type u_1
μ : Type u_2
μ' : Type u_3
inst✝² : AddCommMonoid μ
inst✝¹ : DecidableEq μ
inst✝ : HasAntidiagonal μ
d : ℕ
n : μ
f : Fin d →₀ μ
⊢ f ∈ finAntidiagonal₀ d n ↔ (f.sum fun x x => x) = n
state_after: no goals
Theorem: ProjectiveSpectrum.basicOpen_mul_le_left
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

tactic: rw [basicOpen_mul 𝒜 f g]
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f g : A
⊢ basicOpen 𝒜 (f * g) ≤ basicOpen 𝒜 f
state_after: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f g : A
⊢ basicOpen 𝒜 f ⊓ basicOpen 𝒜 g ≤ basicOpen 𝒜 f

tactic: exact inf_le_left
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f g : A
⊢ basicOpen 𝒜 f ⊓ basicOpen 𝒜 g ≤ basicOpen 𝒜 f
state_after: no goals
Theorem: Filter.comap_surjective_eq_bot
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [comap_eq_bot_iff_compl_range, hm.range_eq, compl_univ, empty_mem_iff_bot]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
m : α → β
hm : Surjective m
⊢ comap m f = ⊥ ↔ f = ⊥
state_after: no goals
Theorem: Batteries.RBNode.foldl_reverse
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: simp (config := {unfoldPartialApp := true})
  [foldr_eq_foldr_toList, foldl_eq_foldl_toList, flip]
state_before: α : Type u_1
β : Type u_2
t : RBNode α
f : β → α → β
init : β
⊢ foldl f init t.reverse = foldr (flip f) t init
state_after: no goals
Theorem: Fin.pos_iff_ne_zero'
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [← val_fin_lt, val_zero', Nat.pos_iff_ne_zero, Ne, Ne, ext_iff, val_zero']
state_before: n m : ℕ
inst✝ : NeZero n
a : Fin n
⊢ 0 < a ↔ a ≠ 0
state_after: no goals
Theorem: Matrix.fromBlocks_map
File: Mathlib/Data/Matrix/Block.lean

tactic: ext i j
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
f : α → β
⊢ (fromBlocks A B C D).map f = fromBlocks (A.map f) (B.map f) (C.map f) (D.map f)
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
f : α → β
i : n ⊕ o
j : l ⊕ m
⊢ (fromBlocks A B C D).map f i j = fromBlocks (A.map f) (B.map f) (C.map f) (D.map f) i j

tactic: rcases i with ⟨⟩ <;> rcases j with ⟨⟩ <;> simp [fromBlocks]
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
f : α → β
i : n ⊕ o
j : l ⊕ m
⊢ (fromBlocks A B C D).map f i j = fromBlocks (A.map f) (B.map f) (C.map f) (D.map f) i j
state_after: no goals
Theorem: Complex.abs_cpow_of_imp
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rcases ne_or_eq z 0 with (hz | rfl) <;> [exact abs_cpow_of_ne_zero hz w; rw [map_zero]]
state_before: z w : ℂ
h : z = 0 → w.re = 0 → w = 0
⊢ abs (z ^ w) = abs z ^ w.re / rexp (z.arg * w.im)
state_after: case inr
w : ℂ
h : 0 = 0 → w.re = 0 → w = 0
⊢ abs (0 ^ w) = 0 ^ w.re / rexp (arg 0 * w.im)

tactic: rcases eq_or_ne w.re 0 with hw | hw
state_before: case inr
w : ℂ
h : 0 = 0 → w.re = 0 → w = 0
⊢ abs (0 ^ w) = 0 ^ w.re / rexp (arg 0 * w.im)
state_after: case inr.inl
w : ℂ
h : 0 = 0 → w.re = 0 → w = 0
hw : w.re = 0
⊢ abs (0 ^ w) = 0 ^ w.re / rexp (arg 0 * w.im)

case inr.inr
w : ℂ
h : 0 = 0 → w.re = 0 → w = 0
hw : w.re ≠ 0
⊢ abs (0 ^ w) = 0 ^ w.re / rexp (arg 0 * w.im)

tactic: simp [hw, h rfl hw]
state_before: case inr.inl
w : ℂ
h : 0 = 0 → w.re = 0 → w = 0
hw : w.re = 0
⊢ abs (0 ^ w) = 0 ^ w.re / rexp (arg 0 * w.im)
state_after: no goals

tactic: rw [Real.zero_rpow hw, zero_div, zero_cpow, map_zero]
state_before: case inr.inr
w : ℂ
h : 0 = 0 → w.re = 0 → w = 0
hw : w.re ≠ 0
⊢ abs (0 ^ w) = 0 ^ w.re / rexp (arg 0 * w.im)
state_after: case inr.inr
w : ℂ
h : 0 = 0 → w.re = 0 → w = 0
hw : w.re ≠ 0
⊢ w ≠ 0

tactic: exact ne_of_apply_ne re hw
state_before: case inr.inr
w : ℂ
h : 0 = 0 → w.re = 0 → w = 0
hw : w.re ≠ 0
⊢ w ≠ 0
state_after: no goals
Theorem: List.indexesValues_eq_filter_enum
File: Mathlib/Data/List/Indexes.lean

tactic: simp (config := { unfoldPartialApp := true }) [indexesValues, foldrIdx_eq_foldr_enum, uncurry,
  filter_eq_foldr, cond_eq_if]
state_before: α : Type u
β : Type v
p : α → Prop
inst✝ : DecidablePred p
as : List α
⊢ indexesValues (fun b => decide (p b)) as = filter ((fun b => decide (p b)) ∘ Prod.snd) as.enum
state_after: no goals
Theorem: Nat.floorRoot_ne_zero
File: Mathlib/Data/Nat/Factorization/Root.lean

tactic: simp (config := { contextual := true }) [floorRoot, not_imp_not, not_or]
state_before: a b n : ℕ
⊢ n.floorRoot a ≠ 0 ↔ n ≠ 0 ∧ a ≠ 0
state_after: no goals
Theorem: Monoid.CoprodI.Word.rcons_eq_smul
File: Mathlib/GroupTheory/CoprodI.lean

tactic: simp [of_smul_def]
state_before: ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i : ι
p : Pair M i
⊢ rcons p = of p.head • p.tail
state_after: no goals