ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AlgebraicGeometry.HasRingHomProperty.app_top
File: Mathlib/AlgebraicGeometry/Morphisms/RingHomProperties.lean

Proof steps:
state_before: P : MorphismProperty Scheme
Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
inst✝² : HasRingHomProperty P Q
X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
H : P f
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
⊢ Q (Scheme.Hom.app f ⊤)
state_after: P : MorphismProperty Scheme
Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
inst✝² : HasRingHomProperty P Q
X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
H : P f
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
⊢ Q (Scheme.Hom.appLE f ⊤ (f ⁻¹ᵁ ⊤) ⋯)
tactic: rw [Scheme.Hom.app_eq_appLE]
state_before: P : MorphismProperty Scheme
Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
inst✝² : HasRingHomProperty P Q
X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
H : P f
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
⊢ Q (Scheme.Hom.appLE f ⊤ (f ⁻¹ᵁ ⊤) ⋯)
state_after: no goals
tactic: exact appLE P f H ⟨_, isAffineOpen_top _⟩ ⟨_, isAffineOpen_top _⟩ _
Theorem: OmegaCompletePartialOrder.Chain.mem_map_iff
File: Mathlib/Order/OmegaCompletePartialOrder.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type u_1
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
c c' : Chain α
f : α →o β
g : β →o γ
b : β
h : ∃ a ∈ c, f a = b
⊢ b ∈ c.map f
state_after: case intro.intro
α : Type u
β : Type v
γ : Type u_1
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
c c' : Chain α
f : α →o β
g : β →o γ
b : β
w : α
h : w ∈ c
h' : f w = b
⊢ b ∈ c.map f
tactic: rcases h with ⟨w, h, h'⟩
state_before: case intro.intro
α : Type u
β : Type v
γ : Type u_1
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
c c' : Chain α
f : α →o β
g : β →o γ
b : β
w : α
h : w ∈ c
h' : f w = b
⊢ b ∈ c.map f
state_after: case intro.intro
α : Type u
β : Type v
γ : Type u_1
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
c c' : Chain α
f : α →o β
g : β →o γ
w : α
h : w ∈ c
⊢ f w ∈ c.map f
tactic: subst b
state_before: case intro.intro
α : Type u
β : Type v
γ : Type u_1
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
c c' : Chain α
f : α →o β
g : β →o γ
w : α
h : w ∈ c
⊢ f w ∈ c.map f
state_after: no goals
tactic: apply mem_map c _ h
Theorem: MonoidAlgebra.single_mul_apply_aux
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

Proof steps:
state_before: k : Type u₁
G : Type u₂
H✝ : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
x y z : G
H : ∀ (a : G), x * a = y ↔ a = z
⊢ (single x r * f) y = r * f z
state_after: no goals
tactic: classical exact
      have : (f.sum fun a b => ite (x * a = y) (0 * b) 0) = 0 := by simp
      calc
        (HMul.hMul (α := MonoidAlgebra k G) (single x r) f) y =
            sum f fun a b => ite (x * a = y) (r * b) 0 :=
          (mul_apply _ _ _).trans <| sum_single_index this
        _ = f.sum fun a b => ite (a = z) (r * b) 0 := by simp only [H]
        _ = if z ∈ f.support then r * f z else 0 := f.support.sum_ite_eq' _ _
        _ = _ := by split_ifs with h <;> simp at h <;> simp [h]
Theorem: Equiv.Perm.disjoint_refl_iff
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
f g h : Perm α
⊢ f.Disjoint f ↔ f = 1
state_after: α : Type u_1
f g h✝ : Perm α
h : f.Disjoint f
⊢ f = 1
tactic: refine ⟨fun h => ?_, fun h => h.symm ▸ disjoint_one_left 1⟩
state_before: α : Type u_1
f g h✝ : Perm α
h : f.Disjoint f
⊢ f = 1
state_after: case H
α : Type u_1
f g h✝ : Perm α
h : f.Disjoint f
x : α
⊢ f x = 1 x
tactic: ext x
state_before: case H
α : Type u_1
f g h✝ : Perm α
h : f.Disjoint f
x : α
⊢ f x = 1 x
state_after: no goals
tactic: cases' h x with hx hx <;> simp [hx]
Theorem: ComplexShape.Embedding.f_eq_of_r_eq_some
File: Mathlib/Algebra/Homology/Embedding/Basic.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
i : ι
i' : ι'
hi : e.r i' = some i
⊢ e.f i = i'
state_after: case pos
ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
i : ι
i' : ι'
hi : e.r i' = some i
h : ∃ k, e.f k = i'
⊢ e.f i = i'

case neg
ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
i : ι
i' : ι'
hi : e.r i' = some i
h : ¬∃ k, e.f k = i'
⊢ e.f i = i'
tactic: by_cases h : ∃ (k : ι), e.f k = i'
Theorem: isLittleO_exp_neg_mul_sq_cocompact
File: Mathlib/Analysis/SpecialFunctions/Gaussian/PoissonSummation.lean

Proof steps:
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℂ
ha : 0 < a.re
s : ℝ
⊢ (fun x => cexp (-a * ↑x ^ 2)) =o[cocompact ℝ] fun x => |x| ^ s
state_after: case h.e'_7
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℂ
ha : 0 < a.re
s : ℝ
⊢ (fun x => cexp (-a * ↑x ^ 2)) = fun x => cexp (-a * ↑x ^ 2 + 0 * ↑x)

E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℂ
ha : 0 < a.re
s : ℝ
⊢ (-a).re < 0
tactic: convert cexp_neg_quadratic_isLittleO_abs_rpow_cocompact (?_ : (-a).re < 0) 0 s using 1
Theorem: tendsto_indicator_cthickening_indicator_closure
File: Mathlib/Topology/MetricSpace/ThickenedIndicator.lean

Proof steps:
state_before: α : Type u_1
inst✝² : PseudoEMetricSpace α
β : Type u_2
inst✝¹ : One β
inst✝ : TopologicalSpace β
f : α → β
E : Set α
⊢ Tendsto (fun δ => (cthickening δ E).mulIndicator f) (𝓝 0) (𝓝 ((closure E).mulIndicator f))
state_after: α : Type u_1
inst✝² : PseudoEMetricSpace α
β : Type u_2
inst✝¹ : One β
inst✝ : TopologicalSpace β
f : α → β
E : Set α
⊢ ∀ (x : α), Tendsto (fun i => (cthickening i E).mulIndicator f x) (𝓝 0) (𝓝 ((closure E).mulIndicator f x))
tactic: rw [tendsto_pi_nhds]
state_before: α : Type u_1
inst✝² : PseudoEMetricSpace α
β : Type u_2
inst✝¹ : One β
inst✝ : TopologicalSpace β
f : α → β
E : Set α
⊢ ∀ (x : α), Tendsto (fun i => (cthickening i E).mulIndicator f x) (𝓝 0) (𝓝 ((closure E).mulIndicator f x))
state_after: α : Type u_1
inst✝² : PseudoEMetricSpace α
β : Type u_2
inst✝¹ : One β
inst✝ : TopologicalSpace β
f : α → β
E : Set α
x : α
⊢ Tendsto (fun i => (cthickening i E).mulIndicator f x) (𝓝 0) (𝓝 ((closure E).mulIndicator f x))
tactic: intro x
state_before: α : Type u_1
inst✝² : PseudoEMetricSpace α
β : Type u_2
inst✝¹ : One β
inst✝ : TopologicalSpace β
f : α → β
E : Set α
x : α
⊢ Tendsto (fun i => (cthickening i E).mulIndicator f x) (𝓝 0) (𝓝 ((closure E).mulIndicator f x))
state_after: α : Type u_1
inst✝² : PseudoEMetricSpace α
β : Type u_2
inst✝¹ : One β
inst✝ : TopologicalSpace β
f : α → β
E : Set α
x : α
⊢ Tendsto (fun x_1 => (closure E).mulIndicator f x) (𝓝 0) (𝓝 ((closure E).mulIndicator f x))
tactic: rw [tendsto_congr' (mulIndicator_cthickening_eventually_eq_mulIndicator_closure f E x)]
state_before: α : Type u_1
inst✝² : PseudoEMetricSpace α
β : Type u_2
inst✝¹ : One β
inst✝ : TopologicalSpace β
f : α → β
E : Set α
x : α
⊢ Tendsto (fun x_1 => (closure E).mulIndicator f x) (𝓝 0) (𝓝 ((closure E).mulIndicator f x))
state_after: no goals
tactic: apply tendsto_const_nhds
Theorem: Finset.compls_sups
File: Mathlib/Data/Finset/Sups.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : BooleanAlgebra α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Finset α
a b c : α
s t : Finset α
⊢ (s ⊻ t)ᶜˢ = sᶜˢ ⊼ tᶜˢ
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : BooleanAlgebra α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Finset α
a b c : α
s t : Finset α
⊢ image compl (s ⊻ t) = image compl s ⊼ image compl t
tactic: simp_rw [← image_compl]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : BooleanAlgebra α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Finset α
a b c : α
s t : Finset α
⊢ image compl (s ⊻ t) = image compl s ⊼ image compl t
state_after: no goals
tactic: exact image_image₂_distrib fun _ _ ↦ compl_sup
Theorem: Continuous.div
File: Mathlib/Topology/Algebra/GroupWithZero.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝⁵ : GroupWithZero G₀
inst✝⁴ : TopologicalSpace G₀
inst✝³ : HasContinuousInv₀ G₀
inst✝² : ContinuousMul G₀
f g : α → G₀
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s : Set α
a : α
hf : Continuous f
hg : Continuous g
h₀ : ∀ (x : α), g x ≠ 0
⊢ Continuous (f / g)
state_after: no goals
tactic: simpa only [div_eq_mul_inv] using hf.mul (hg.inv₀ h₀)
Theorem: Pell.isPell_nat
File: Mathlib/NumberTheory/PellMatiyasevic.lean

Proof steps:
state_before: a : ℕ
a1 : 1 < a
x y : ℕ
h : IsPell { re := ↑x, im := ↑y }
⊢ ↑(x * x - Pell.d a1 * y * y) = ↑1
state_after: a : ℕ
a1 : 1 < a
x y : ℕ
h : IsPell { re := ↑x, im := ↑y }
⊢ ↑(x * x) - ↑(Pell.d a1 * y * y) = ↑1
tactic: rw [Int.ofNat_sub (Int.le_of_ofNat_le_ofNat <| Int.le.intro_sub _ h)]
state_before: a : ℕ
a1 : 1 < a
x y : ℕ
h : IsPell { re := ↑x, im := ↑y }
⊢ ↑(x * x) - ↑(Pell.d a1 * y * y) = ↑1
state_after: no goals
tactic: exact h
state_before: a : ℕ
a1 : 1 < a
x y : ℕ
h : x * x - Pell.d a1 * y * y = 1
⊢ ↑(x * x) - ↑(Pell.d a1 * y * y) = 1
state_after: a : ℕ
a1 : 1 < a
x y : ℕ
h : x * x - Pell.d a1 * y * y = 1
⊢ ↑1 = 1
tactic: rw [← Int.ofNat_sub <| le_of_lt <| Nat.lt_of_sub_eq_succ h, h]
state_before: a : ℕ
a1 : 1 < a
x y : ℕ
h : x * x - Pell.d a1 * y * y = 1
⊢ ↑1 = 1
state_after: no goals
tactic: rfl
Theorem: Finset.mem_falling
File: Mathlib/Combinatorics/SetFamily/LYM.lean

Proof steps:
state_before: 𝕜 : Type u_1
α : Type u_2
inst✝¹ : LinearOrderedField 𝕜
inst✝ : DecidableEq α
k : ℕ
𝒜 : Finset (Finset α)
s : Finset α
⊢ s ∈ falling k 𝒜 ↔ (∃ t ∈ 𝒜, s ⊆ t) ∧ s.card = k
state_after: 𝕜 : Type u_1
α : Type u_2
inst✝¹ : LinearOrderedField 𝕜
inst✝ : DecidableEq α
k : ℕ
𝒜 : Finset (Finset α)
s : Finset α
⊢ (∃ v ∈ 𝒜, s ⊆ v ∧ s.card = k) ↔ (∃ t ∈ 𝒜, s ⊆ t) ∧ s.card = k
tactic: simp_rw [falling, mem_sup, mem_powersetCard]
state_before: 𝕜 : Type u_1
α : Type u_2
inst✝¹ : LinearOrderedField 𝕜
inst✝ : DecidableEq α
k : ℕ
𝒜 : Finset (Finset α)
s : Finset α
⊢ (∃ v ∈ 𝒜, s ⊆ v ∧ s.card = k) ↔ (∃ t ∈ 𝒜, s ⊆ t) ∧ s.card = k
state_after: no goals
tactic: aesop
Theorem: lp.norm_rpow_eq_tsum
File: Mathlib/Analysis/Normed/Lp/lpSpace.lean

Proof steps:
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < p.toReal
f : ↥(lp E p)
⊢ ‖f‖ ^ p.toReal = ∑' (i : α), ‖↑f i‖ ^ p.toReal
state_after: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < p.toReal
f : ↥(lp E p)
⊢ (∑' (i : α), ‖↑f i‖ ^ p.toReal) ^ (1 / p.toReal * p.toReal) = ∑' (i : α), ‖↑f i‖ ^ p.toReal

case hx
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < p.toReal
f : ↥(lp E p)
⊢ 0 ≤ ∑' (i : α), ‖↑f i‖ ^ p.toReal
tactic: rw [norm_eq_tsum_rpow hp, ← Real.rpow_mul]
state_before: case hx
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < p.toReal
f : ↥(lp E p)
⊢ 0 ≤ ∑' (i : α), ‖↑f i‖ ^ p.toReal
state_after: case hx.h
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < p.toReal
f : ↥(lp E p)
⊢ ∀ (i : α), 0 ≤ ‖↑f i‖ ^ p.toReal
tactic: apply tsum_nonneg
state_before: case hx.h
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < p.toReal
f : ↥(lp E p)
⊢ ∀ (i : α), 0 ≤ ‖↑f i‖ ^ p.toReal
state_after: case hx.h
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < p.toReal
f : ↥(lp E p)
i : α
⊢ 0 ≤ ‖↑f i‖ ^ p.toReal
tactic: intro i
state_before: case hx.h
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < p.toReal
f : ↥(lp E p)
i : α
⊢ 0 ≤ ‖↑f i‖ ^ p.toReal
state_after: no goals
tactic: calc
    (0 : ℝ) = (0 : ℝ) ^ p.toReal := by rw [Real.zero_rpow hp.ne']
    _ ≤ _ := by gcongr; apply norm_nonneg
Theorem: Finset.mulEnergy_eq_zero_iff
File: Mathlib/Combinatorics/Additive/Energy.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s s₁ s₂ t t₁ t₂ : Finset α
⊢ Eₘ[s, t] = 0 ↔ s = ∅ ∨ t = ∅
state_after: no goals
tactic: simp [← (Nat.zero_le _).not_gt_iff_eq, not_and_or, imp_iff_or_not, or_comm]
Theorem: DFinsupp.mapRange.addEquiv_trans
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → AddZeroClass (β i)
inst✝¹ : (i : ι) → AddZeroClass (β₁ i)
inst✝ : (i : ι) → AddZeroClass (β₂ i)
f : (i : ι) → β i ≃+ β₁ i
f₂ : (i : ι) → β₁ i ≃+ β₂ i
⊢ (addEquiv fun i => (f i).trans (f₂ i)) = (addEquiv f).trans (addEquiv f₂)
state_after: case refine_1
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → AddZeroClass (β i)
inst✝¹ : (i : ι) → AddZeroClass (β₁ i)
inst✝ : (i : ι) → AddZeroClass (β₂ i)
f : (i : ι) → β i ≃+ β₁ i
f₂ : (i : ι) → β₁ i ≃+ β₂ i
⊢ ∀ (i : ι), (fun i x => (f₂ i) x) i 0 = 0

case refine_2
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → AddZeroClass (β i)
inst✝¹ : (i : ι) → AddZeroClass (β₁ i)
inst✝ : (i : ι) → AddZeroClass (β₂ i)
f : (i : ι) → β i ≃+ β₁ i
f₂ : (i : ι) → β₁ i ≃+ β₂ i
⊢ ∀ (i : ι), (fun i x => (f i) x) i 0 = 0

case refine_3
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → AddZeroClass (β i)
inst✝¹ : (i : ι) → AddZeroClass (β₁ i)
inst✝ : (i : ι) → AddZeroClass (β₂ i)
f : (i : ι) → β i ≃+ β₁ i
f₂ : (i : ι) → β₁ i ≃+ β₂ i
⊢ ∀ (i : ι), ((fun i x => (f₂ i) x) i ∘ (fun i x => (f i) x) i) 0 = 0
tactic: refine AddEquiv.ext <| mapRange_comp (fun i x => f₂ i x) (fun i x => f i x) ?_ ?_ ?_
Theorem: AddCommGroup.sub_modEq_zero
File: Mathlib/Algebra/ModEq.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
⊢ a - b ≡ 0 [PMOD p] ↔ a ≡ b [PMOD p]
state_after: no goals
tactic: simp [sub_modEq_iff_modEq_add]
Theorem: KaehlerDifferential.kerToTensor_apply
File: Mathlib/RingTheory/Kaehler/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹⁵ : CommRing R
inst✝¹⁴ : CommRing S
inst✝¹³ : Algebra R S
M : Type u_1
inst✝¹² : AddCommGroup M
inst✝¹¹ : Module R M
inst✝¹⁰ : Module S M
inst✝⁹ : IsScalarTower R S M
A : Type u_2
B : Type u_3
inst✝⁸ : CommRing A
inst✝⁷ : CommRing B
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra R B
inst✝⁴ : Algebra A B
inst✝³ : Algebra S B
inst✝² : IsScalarTower R A B
inst✝¹ : IsScalarTower R S B
inst✝ : SMulCommClass S A B
x y : ↥(RingHom.ker (algebraMap A B))
⊢ (fun x => 1 ⊗ₜ[A] (D R A) ↑x) (x + y) = (fun x => 1 ⊗ₜ[A] (D R A) ↑x) x + (fun x => 1 ⊗ₜ[A] (D R A) ↑x) y
state_after: no goals
tactic: simp only [AddSubmonoid.coe_add, Submodule.coe_toAddSubmonoid, map_add,
    TensorProduct.tmul_add]
state_before: R : Type u
S : Type v
inst✝¹⁵ : CommRing R
inst✝¹⁴ : CommRing S
inst✝¹³ : Algebra R S
M : Type u_1
inst✝¹² : AddCommGroup M
inst✝¹¹ : Module R M
inst✝¹⁰ : Module S M
inst✝⁹ : IsScalarTower R S M
A : Type u_2
B : Type u_3
inst✝⁸ : CommRing A
inst✝⁷ : CommRing B
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra R B
inst✝⁴ : Algebra A B
inst✝³ : Algebra S B
inst✝² : IsScalarTower R A B
inst✝¹ : IsScalarTower R S B
inst✝ : SMulCommClass S A B
r : A
x : ↥(RingHom.ker (algebraMap A B))
⊢ { toFun := fun x => 1 ⊗ₜ[A] (D R A) ↑x, map_add' := ⋯ }.toFun (r • x) =
    (RingHom.id A) r • { toFun := fun x => 1 ⊗ₜ[A] (D R A) ↑x, map_add' := ⋯ }.toFun x
state_after: no goals
tactic: simp only [SetLike.val_smul, Derivation.leibniz, RingHom.id_apply,
    TensorProduct.tmul_smul, TensorProduct.smul_tmul', add_zero, ← Algebra.algebraMap_eq_smul_one,
    TensorProduct.zero_tmul, smul_eq_mul, TensorProduct.tmul_add, (RingHom.mem_ker _).mp x.prop]
Theorem: Equiv.Perm.sign_prod_list_swap
File: Mathlib/GroupTheory/Perm/Sign.lean

Proof steps:
state_before: α : Type u
inst✝¹ : DecidableEq α
β : Type v
inst✝ : Fintype α
l : List (Perm α)
hl : ∀ g ∈ l, g.IsSwap
⊢ sign l.prod = (-1) ^ l.length
state_after: α : Type u
inst✝¹ : DecidableEq α
β : Type v
inst✝ : Fintype α
l : List (Perm α)
hl : ∀ g ∈ l, g.IsSwap
h₁ : List.map (⇑sign) l = List.replicate l.length (-1)
⊢ sign l.prod = (-1) ^ l.length
tactic: have h₁ : l.map sign = List.replicate l.length (-1) :=
    List.eq_replicate.2
      ⟨by simp, fun u hu =>
        let ⟨g, hg⟩ := List.mem_map.1 hu
        hg.2 ▸ (hl _ hg.1).sign_eq⟩
state_before: α : Type u
inst✝¹ : DecidableEq α
β : Type v
inst✝ : Fintype α
l : List (Perm α)
hl : ∀ g ∈ l, g.IsSwap
h₁ : List.map (⇑sign) l = List.replicate l.length (-1)
⊢ sign l.prod = (-1) ^ l.length
state_after: no goals
tactic: rw [← List.prod_replicate, ← h₁, List.prod_hom _ (@sign α _ _)]
Theorem: Subgroup.val_mem_ofUnits_iff_mem
File: Mathlib/Algebra/Group/Submonoid/Units.lean

Proof steps:
state_before: M : Type u_1
inst✝¹ : Monoid M
G : Type u_2
inst✝ : Group G
H : Subgroup Gˣ
x : Gˣ
⊢ ↑x ∈ H.ofUnits ↔ x ∈ H
state_after: no goals
tactic: simp_rw [mem_ofUnits_iff_toUnits_mem, toUnits_val_apply]
Theorem: EuclideanDomain.lt_one
File: Mathlib/Algebra/EuclideanDomain/Defs.lean

Proof steps:
state_before: R : Type u
inst✝ : EuclideanDomain R
a : R
this : (p : Prop) → Decidable p
h : ¬a = 0
⊢ ¬a ≺ 1
state_after: no goals
tactic: simpa only [one_mul] using mul_left_not_lt 1 h
Theorem: CochainComplex.mappingCone.inl_snd
File: Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.29264, u_2} D
inst✝² : Preadditive C
inst✝¹ : Preadditive D
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
⊢ (inl φ).comp (snd φ) ⋯ = 0
state_after: case h
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.29264, u_2} D
inst✝² : Preadditive C
inst✝¹ : Preadditive D
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
p q : ℤ
hpq : p + -1 = q
⊢ ((inl φ).comp (snd φ) ⋯).v p q hpq = Cochain.v 0 p q hpq
tactic: ext p q hpq
state_before: case h
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.29264, u_2} D
inst✝² : Preadditive C
inst✝¹ : Preadditive D
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
p q : ℤ
hpq : p + -1 = q
⊢ ((inl φ).comp (snd φ) ⋯).v p q hpq = Cochain.v 0 p q hpq
state_after: no goals
tactic: simp [Cochain.comp_v _ _ (add_zero (-1)) p q q (by omega) (by omega)]
Theorem: omegaLimit_subset_of_tendsto
File: Mathlib/Dynamics/OmegaLimit.lean

Proof steps:
state_before: τ : Type u_1
α : Type u_2
β : Type u_3
ι : Type u_4
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
m : τ → τ
f₁ f₂ : Filter τ
hf : Tendsto m f₁ f₂
⊢ ω f₁ (fun t x => ϕ (m t) x) s ⊆ ω f₂ ϕ s
state_after: τ : Type u_1
α : Type u_2
β : Type u_3
ι : Type u_4
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
m : τ → τ
f₁ f₂ : Filter τ
hf : Tendsto m f₁ f₂
u : Set τ
hu : u ∈ f₂
⊢ closure (image2 (fun t x => ϕ (m t) x) (m ⁻¹' u) s) ⊆ closure (image2 ϕ u s)
tactic: refine iInter₂_mono' fun u hu ↦ ⟨m ⁻¹' u, tendsto_def.mp hf _ hu, ?_⟩
state_before: τ : Type u_1
α : Type u_2
β : Type u_3
ι : Type u_4
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
m : τ → τ
f₁ f₂ : Filter τ
hf : Tendsto m f₁ f₂
u : Set τ
hu : u ∈ f₂
⊢ closure (image2 (fun t x => ϕ (m t) x) (m ⁻¹' u) s) ⊆ closure (image2 ϕ u s)
state_after: τ : Type u_1
α : Type u_2
β : Type u_3
ι : Type u_4
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
m : τ → τ
f₁ f₂ : Filter τ
hf : Tendsto m f₁ f₂
u : Set τ
hu : u ∈ f₂
⊢ closure (image2 ϕ (m '' (m ⁻¹' u)) s) ⊆ closure (image2 ϕ u s)
tactic: rw [← image2_image_left]
state_before: τ : Type u_1
α : Type u_2
β : Type u_3
ι : Type u_4
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
m : τ → τ
f₁ f₂ : Filter τ
hf : Tendsto m f₁ f₂
u : Set τ
hu : u ∈ f₂
⊢ closure (image2 ϕ (m '' (m ⁻¹' u)) s) ⊆ closure (image2 ϕ u s)
state_after: no goals
tactic: exact closure_mono (image2_subset (image_preimage_subset _ _) Subset.rfl)
Theorem: SimpleGraph.IsSRGWith.card_commonNeighbors_eq_of_not_adj_compl
File: Mathlib/Combinatorics/SimpleGraph/StronglyRegular.lean

Proof steps:
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
h : G.IsSRGWith n k ℓ μ
v w : V
hn : v ≠ w
hna : ¬Gᶜ.Adj v w
⊢ Fintype.card ↑(Gᶜ.commonNeighbors v w) = n - (2 * k - ℓ)
state_after: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
h : G.IsSRGWith n k ℓ μ
v w : V
hn : v ≠ w
hna : ¬Gᶜ.Adj v w
⊢ ((G.neighborFinset v)ᶜ \ {v} ∩ ((G.neighborFinset w)ᶜ \ {w})).card = n - (2 * k - ℓ)
tactic: simp only [← Set.toFinset_card, commonNeighbors, Set.toFinset_inter, neighborSet_compl,
    Set.toFinset_diff, Set.toFinset_singleton, Set.toFinset_compl, ← neighborFinset_def]
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
h : G.IsSRGWith n k ℓ μ
v w : V
hn : v ≠ w
hna : ¬Gᶜ.Adj v w
⊢ ((G.neighborFinset v)ᶜ \ {v} ∩ ((G.neighborFinset w)ᶜ \ {w})).card = n - (2 * k - ℓ)
state_after: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
h : G.IsSRGWith n k ℓ μ
v w : V
hn : v ≠ w
hna : v ≠ w → G.Adj v w
⊢ ((G.neighborFinset v)ᶜ \ {v} ∩ ((G.neighborFinset w)ᶜ \ {w})).card = n - (2 * k - ℓ)
tactic: simp only [not_and, Classical.not_not, compl_adj] at hna
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
h : G.IsSRGWith n k ℓ μ
v w : V
hn : v ≠ w
hna : v ≠ w → G.Adj v w
⊢ ((G.neighborFinset v)ᶜ \ {v} ∩ ((G.neighborFinset w)ᶜ \ {w})).card = n - (2 * k - ℓ)
state_after: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
h : G.IsSRGWith n k ℓ μ
v w : V
hn : v ≠ w
hna : v ≠ w → G.Adj v w
h2' : G.Adj v w
⊢ ((G.neighborFinset v)ᶜ \ {v} ∩ ((G.neighborFinset w)ᶜ \ {w})).card = n - (2 * k - ℓ)
tactic: have h2' := hna hn
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
h : G.IsSRGWith n k ℓ μ
v w : V
hn : v ≠ w
hna : v ≠ w → G.Adj v w
h2' : G.Adj v w
⊢ ((G.neighborFinset v)ᶜ \ {v} ∩ ((G.neighborFinset w)ᶜ \ {w})).card = n - (2 * k - ℓ)
state_after: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
h : G.IsSRGWith n k ℓ μ
v w : V
hn : v ≠ w
hna : v ≠ w → G.Adj v w
h2' : G.Adj v w
⊢ ((G.neighborFinset v)ᶜ ∩ (G.neighborFinset w)ᶜ).card = n - (2 * k - ℓ)
tactic: simp_rw [compl_neighborFinset_sdiff_inter_eq, sdiff_compl_neighborFinset_inter_eq h2']
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
h : G.IsSRGWith n k ℓ μ
v w : V
hn : v ≠ w
hna : v ≠ w → G.Adj v w
h2' : G.Adj v w
⊢ ((G.neighborFinset v)ᶜ ∩ (G.neighborFinset w)ᶜ).card = n - (2 * k - ℓ)
state_after: no goals
tactic: rwa [← Finset.compl_union, card_compl, h.card_neighborFinset_union_of_adj, ← h.card]
Theorem: List.cyclicPermutations_of_ne_nil
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
l✝ l' l : List α
h : l ≠ []
⊢ l.cyclicPermutations = (zipWith (fun x x_1 => x ++ x_1) l.tails l.inits).dropLast
state_after: case intro.intro
α : Type u
l l' : List α
hd : α
tl : List α
h : hd :: tl ≠ []
⊢ (hd :: tl).cyclicPermutations = (zipWith (fun x x_1 => x ++ x_1) (hd :: tl).tails (hd :: tl).inits).dropLast
tactic: obtain ⟨hd, tl, rfl⟩ := exists_cons_of_ne_nil h
state_before: case intro.intro
α : Type u
l l' : List α
hd : α
tl : List α
h : hd :: tl ≠ []
⊢ (hd :: tl).cyclicPermutations = (zipWith (fun x x_1 => x ++ x_1) (hd :: tl).tails (hd :: tl).inits).dropLast
state_after: no goals
tactic: exact cyclicPermutations_cons _ _
Theorem: FreeAddGroup.equivalence_join_red
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ a b✝ c b : List (α × Bool)
hab hac : Red.Step a b
⊢ ReflGen Red.Step b b
state_after: no goals
tactic: rfl
state_before: α : Type u
L L₁ L₂ L₃ L₄ a b✝ c b : List (α × Bool)
hab hac : Red.Step a b
⊢ ReflTransGen Red.Step b b
state_after: no goals
tactic: rfl