ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.Measure.MutuallySingular.rnDeriv_ae_eq_zero
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
hμν : μ ⟂ₘ ν
⊢ μ.rnDeriv ν =ᶠ[ae ν] 0
state_after: case pos
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
hμν : μ ⟂ₘ ν
h : μ.HaveLebesgueDecomposition ν
⊢ μ.rnDeriv ν =ᶠ[ae ν] 0

case neg
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
hμν : μ ⟂ₘ ν
h : ¬μ.HaveLebesgueDecomposition ν
⊢ μ.rnDeriv ν =ᶠ[ae ν] 0
tactic: by_cases h : μ.HaveLebesgueDecomposition ν
Theorem: AddSubgroup.isComplement_univ_left
File: Mathlib/GroupTheory/Complement.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
⊢ IsComplement univ S ↔ ∃ g, S = {g}
state_after: case refine_1
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : IsComplement univ S
⊢ S.Nonempty

case refine_2
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : IsComplement univ S
a : G
ha : a ∈ S
b : G
hb : b ∈ S
⊢ a = b

case refine_3
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
⊢ (∃ g, S = {g}) → IsComplement univ S
tactic: refine
    ⟨fun h => Set.exists_eq_singleton_iff_nonempty_subsingleton.mpr ⟨?_, fun a ha b hb => ?_⟩, ?_⟩
Theorem: MulAction.mem_stabilizer_finset
File: Mathlib/Algebra/Pointwise/Stabilizer.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
inst✝³ : Group G
inst✝² : Group H
inst✝¹ : MulAction G α
a : G
inst✝ : DecidableEq α
s : Finset α
⊢ a ∈ stabilizer G s ↔ ∀ (b : α), a • b ∈ s ↔ b ∈ s
state_after: no goals
tactic: simp_rw [← stabilizer_coe_finset, mem_stabilizer_set, Finset.mem_coe]
Theorem: IsCompact.inter_iInter_nonempty
File: Mathlib/Topology/Compactness/Compact.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι✝ : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t✝ : Set X
ι : Type v
hs : IsCompact s
t : ι → Set X
htc : ∀ (i : ι), IsClosed (t i)
hst : ∀ (u : Finset ι), (s ∩ ⋂ i ∈ u, t i).Nonempty
⊢ (s ∩ ⋂ i, t i).Nonempty
state_after: X : Type u
Y : Type v
ι✝ : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t✝ : Set X
ι : Type v
hs : IsCompact s
t : ι → Set X
htc : ∀ (i : ι), IsClosed (t i)
hst : s ∩ ⋂ i, t i = ∅
⊢ ∃ u, s ∩ ⋂ i ∈ u, t i = ∅
tactic: contrapose! hst
state_before: X : Type u
Y : Type v
ι✝ : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t✝ : Set X
ι : Type v
hs : IsCompact s
t : ι → Set X
htc : ∀ (i : ι), IsClosed (t i)
hst : s ∩ ⋂ i, t i = ∅
⊢ ∃ u, s ∩ ⋂ i ∈ u, t i = ∅
state_after: no goals
tactic: exact hs.elim_finite_subfamily_closed t htc hst
Theorem: MvPolynomial.polynomial_eval_eval₂
File: Mathlib/Algebra/MvPolynomial/Polynomial.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
σ : Type u_3
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
x : S
f : R →+* Polynomial S
g : σ → Polynomial S
p : MvPolynomial σ R
⊢ Polynomial.eval x (eval₂ f g p) = eval₂ ((Polynomial.evalRingHom x).comp f) (fun s => Polynomial.eval x (g s)) p
state_after: case h_C
R : Type u_1
S : Type u_2
σ : Type u_3
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
x : S
f : R →+* Polynomial S
g : σ → Polynomial S
p : MvPolynomial σ R
⊢ ∀ (a : R),
    Polynomial.eval x (eval₂ f g (C a)) =
      eval₂ ((Polynomial.evalRingHom x).comp f) (fun s => Polynomial.eval x (g s)) (C a)

case h_add
R : Type u_1
S : Type u_2
σ : Type u_3
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
x : S
f : R →+* Polynomial S
g : σ → Polynomial S
p : MvPolynomial σ R
⊢ ∀ (p q : MvPolynomial σ R),
    Polynomial.eval x (eval₂ f g p) = eval₂ ((Polynomial.evalRingHom x).comp f) (fun s => Polynomial.eval x (g s)) p →
      Polynomial.eval x (eval₂ f g q) = eval₂ ((Polynomial.evalRingHom x).comp f) (fun s => Polynomial.eval x (g s)) q →
        Polynomial.eval x (eval₂ f g (p + q)) =
          eval₂ ((Polynomial.evalRingHom x).comp f) (fun s => Polynomial.eval x (g s)) (p + q)

case h_X
R : Type u_1
S : Type u_2
σ : Type u_3
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
x : S
f : R →+* Polynomial S
g : σ → Polynomial S
p : MvPolynomial σ R
⊢ ∀ (p : MvPolynomial σ R) (n : σ),
    Polynomial.eval x (eval₂ f g p) = eval₂ ((Polynomial.evalRingHom x).comp f) (fun s => Polynomial.eval x (g s)) p →
      Polynomial.eval x (eval₂ f g (p * X n)) =
        eval₂ ((Polynomial.evalRingHom x).comp f) (fun s => Polynomial.eval x (g s)) (p * X n)
tactic: apply induction_on p
Theorem: Finset.eraseNone_map_some
File: Mathlib/Data/Finset/Option.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s : Finset α
⊢ eraseNone (map Embedding.some s) = s
state_after: case a
α : Type u_1
β : Type u_2
s : Finset α
a✝ : α
⊢ a✝ ∈ eraseNone (map Embedding.some s) ↔ a✝ ∈ s
tactic: ext
state_before: case a
α : Type u_1
β : Type u_2
s : Finset α
a✝ : α
⊢ a✝ ∈ eraseNone (map Embedding.some s) ↔ a✝ ∈ s
state_after: no goals
tactic: simp
Theorem: AlgebraicGeometry.Scheme.Pullback.t'_snd_snd
File: Mathlib/AlgebraicGeometry/Pullbacks.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫
      pullback.snd (fV 𝒰 f g j k) (fV 𝒰 f g j i) ≫ pullback.snd (pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i) =
    pullback.fst (fV 𝒰 f g i j) (fV 𝒰 f g i k) ≫
      pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j) ≫ pullback.fst (𝒰.map i ≫ f) g
state_after: no goals
tactic: simp only [t', Category.assoc, pullbackSymmetry_hom_comp_snd_assoc,
    pullbackRightPullbackFstIso_inv_fst_assoc, pullback.lift_fst_assoc, t_snd,
    pullbackRightPullbackFstIso_hom_fst_assoc]
Theorem: Subalgebra.bot_eq_top_iff_rank_eq_one
File: Mathlib/LinearAlgebra/Dimension/FreeAndStrongRankCondition.lean

Proof steps:
state_before: F : Type u_1
E : Type u_2
inst✝⁵ : CommRing F
inst✝⁴ : StrongRankCondition F
inst✝³ : Ring E
inst✝² : Algebra F E
S : Subalgebra F E
inst✝¹ : Nontrivial E
inst✝ : Module.Free F E
⊢ ⊥ = ⊤ ↔ Module.rank F E = 1
state_after: F : Type u_1
E : Type u_2
inst✝⁵ : CommRing F
inst✝⁴ : StrongRankCondition F
inst✝³ : Ring E
inst✝² : Algebra F E
S : Subalgebra F E
inst✝¹ : Nontrivial E
inst✝ : Module.Free F E
this : Module.Free F ↥⊤
⊢ ⊥ = ⊤ ↔ Module.rank F E = 1
tactic: haveI := Module.Free.of_equiv (Subalgebra.topEquiv (R := F) (A := E)).toLinearEquiv.symm
state_before: F : Type u_1
E : Type u_2
inst✝⁵ : CommRing F
inst✝⁴ : StrongRankCondition F
inst✝³ : Ring E
inst✝² : Algebra F E
S : Subalgebra F E
inst✝¹ : Nontrivial E
inst✝ : Module.Free F E
this : Module.Free F ↥⊤
⊢ ⊥ = ⊤ ↔ Module.rank F E = 1
state_after: no goals
tactic: rw [← rank_top, Subalgebra.rank_eq_one_iff, eq_comm]
Theorem: hasDerivAt_fourier_neg
File: Mathlib/Analysis/Fourier/AddCircle.lean

Proof steps:
state_before: T : ℝ
n : ℤ
x : ℝ
⊢ HasDerivAt (fun y => (fourier (-n)) ↑y) (-2 * ↑π * I * ↑n / ↑T * (fourier (-n)) ↑x) x
state_after: no goals
tactic: simpa using hasDerivAt_fourier T (-n) x
Theorem: mul_self_eq_zero
File: Mathlib/Algebra/GroupWithZero/Defs.lean

Proof steps:
state_before: G₀ : Type u
M₀ : Type u_1
M₀' : Type u_2
G₀' : Type u_3
inst✝¹ : MulZeroClass M₀
inst✝ : NoZeroDivisors M₀
a b : M₀
⊢ a * a = 0 ↔ a = 0
state_after: no goals
tactic: simp
Theorem: DFinsupp.addHom_ext
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)
γ : Type w
inst✝ : AddZeroClass γ
f g : (Π₀ (i : ι), β i) →+ γ
H : ∀ (i : ι) (y : β i), f (single i y) = g (single i y)
⊢ f = g
state_after: ι : Type u
γ✝ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → AddZeroClass (β i)
γ : Type w
inst✝ : AddZeroClass γ
f✝ g : (Π₀ (i : ι), β i) →+ γ
H : ∀ (i : ι) (y : β i), f✝ (single i y) = g (single i y)
f : Π₀ (i : ι), β i
hf : f ∈ ⋃ i, Set.range (single i)
⊢ f✝ f = g f
tactic: refine AddMonoidHom.eq_of_eqOn_denseM add_closure_iUnion_range_single fun f hf => ?_
state_before: ι : Type u
γ✝ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → AddZeroClass (β i)
γ : Type w
inst✝ : AddZeroClass γ
f✝ g : (Π₀ (i : ι), β i) →+ γ
H : ∀ (i : ι) (y : β i), f✝ (single i y) = g (single i y)
f : Π₀ (i : ι), β i
hf : f ∈ ⋃ i, Set.range (single i)
⊢ f✝ f = g f
state_after: ι : Type u
γ✝ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → AddZeroClass (β i)
γ : Type w
inst✝ : AddZeroClass γ
f✝ g : (Π₀ (i : ι), β i) →+ γ
H : ∀ (i : ι) (y : β i), f✝ (single i y) = g (single i y)
f : Π₀ (i : ι), β i
hf : ∃ i y, single i y = f
⊢ f✝ f = g f
tactic: simp only [Set.mem_iUnion, Set.mem_range] at hf
state_before: ι : Type u
γ✝ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → AddZeroClass (β i)
γ : Type w
inst✝ : AddZeroClass γ
f✝ g : (Π₀ (i : ι), β i) →+ γ
H : ∀ (i : ι) (y : β i), f✝ (single i y) = g (single i y)
f : Π₀ (i : ι), β i
hf : ∃ i y, single i y = f
⊢ f✝ f = g f
state_after: case intro.intro
ι : Type u
γ✝ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → AddZeroClass (β i)
γ : Type w
inst✝ : AddZeroClass γ
f g : (Π₀ (i : ι), β i) →+ γ
H : ∀ (i : ι) (y : β i), f (single i y) = g (single i y)
x : ι
y : β x
⊢ f (single x y) = g (single x y)
tactic: rcases hf with ⟨x, y, rfl⟩
state_before: case intro.intro
ι : Type u
γ✝ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → AddZeroClass (β i)
γ : Type w
inst✝ : AddZeroClass γ
f g : (Π₀ (i : ι), β i) →+ γ
H : ∀ (i : ι) (y : β i), f (single i y) = g (single i y)
x : ι
y : β x
⊢ f (single x y) = g (single x y)
state_after: no goals
tactic: apply H
Theorem: EMetric.cauchySeq_iff_le_tendsto_0
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : PseudoEMetricSpace α
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
s : β → α
⊢ (∀ ε > 0, ∃ N, ∀ (m : β), N ≤ m → ∀ (n : β), N ≤ n → edist (s m) (s n) < ε) ↔
    ∃ b, (∀ (n m N : β), N ≤ n → N ≤ m → edist (s n) (s m) ≤ b N) ∧ Tendsto b atTop (𝓝 0)
state_after: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : PseudoEMetricSpace α
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
s : β → α
⊢ (∀ ε > 0, ∃ N, ∀ (m : β), N ≤ m → ∀ (n : β), N ≤ n → edist (s m) (s n) < ε) →
    ∃ b, (∀ (n m N : β), N ≤ n → N ≤ m → edist (s n) (s m) ≤ b N) ∧ Tendsto b atTop (𝓝 0)

case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : PseudoEMetricSpace α
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
s : β → α
⊢ (∃ b, (∀ (n m N : β), N ≤ n → N ≤ m → edist (s n) (s m) ≤ b N) ∧ Tendsto b atTop (𝓝 0)) →
    ∀ ε > 0, ∃ N, ∀ (m : β), N ≤ m → ∀ (n : β), N ≤ n → edist (s m) (s n) < ε
tactic: constructor
Theorem: Hindman.FP.finset_prod
File: Mathlib/Combinatorics/Hindman.lean

Proof steps:
state_before: M : Type u_1
inst✝ : CommMonoid M
a : Stream' M
s : Finset ℕ
hs : s.Nonempty
⊢ ∏ i ∈ s, a.get i ∈ FP a
state_after: M : Type u_1
inst✝ : CommMonoid M
a : Stream' M
s : Finset ℕ
hs : s.Nonempty
⊢ ∏ i ∈ s, a.get i ∈ FP (Stream'.drop (s.min' hs) a)
tactic: refine FP_drop_subset_FP _ (s.min' hs) ?_
state_before: M : Type u_1
inst✝ : CommMonoid M
a : Stream' M
s : Finset ℕ
hs : s.Nonempty
⊢ ∏ i ∈ s, a.get i ∈ FP (Stream'.drop (s.min' hs) a)
state_after: case H
M : Type u_1
inst✝ : CommMonoid M
a : Stream' M
s : Finset ℕ
ih : ∀ t ⊂ s, ∀ (hs : t.Nonempty), ∏ i ∈ t, a.get i ∈ FP (Stream'.drop (t.min' hs) a)
hs : s.Nonempty
⊢ ∏ i ∈ s, a.get i ∈ FP (Stream'.drop (s.min' hs) a)
tactic: induction' s using Finset.strongInduction with s ih
state_before: case H
M : Type u_1
inst✝ : CommMonoid M
a : Stream' M
s : Finset ℕ
ih : ∀ t ⊂ s, ∀ (hs : t.Nonempty), ∏ i ∈ t, a.get i ∈ FP (Stream'.drop (t.min' hs) a)
hs : s.Nonempty
⊢ ∏ i ∈ s, a.get i ∈ FP (Stream'.drop (s.min' hs) a)
state_after: case H
M : Type u_1
inst✝ : CommMonoid M
a : Stream' M
s : Finset ℕ
ih : ∀ t ⊂ s, ∀ (hs : t.Nonempty), ∏ i ∈ t, a.get i ∈ FP (Stream'.drop (t.min' hs) a)
hs : s.Nonempty
⊢ (Stream'.drop (s.min' hs) a).head * ∏ x ∈ s.erase (s.min' hs), a.get x ∈ FP (Stream'.drop (s.min' hs) a)
tactic: rw [← Finset.mul_prod_erase _ _ (s.min'_mem hs), ← Stream'.head_drop]
state_before: case H
M : Type u_1
inst✝ : CommMonoid M
a : Stream' M
s : Finset ℕ
ih : ∀ t ⊂ s, ∀ (hs : t.Nonempty), ∏ i ∈ t, a.get i ∈ FP (Stream'.drop (t.min' hs) a)
hs : s.Nonempty
⊢ (Stream'.drop (s.min' hs) a).head * ∏ x ∈ s.erase (s.min' hs), a.get x ∈ FP (Stream'.drop (s.min' hs) a)
state_after: case H.inl
M : Type u_1
inst✝ : CommMonoid M
a : Stream' M
s : Finset ℕ
ih : ∀ t ⊂ s, ∀ (hs : t.Nonempty), ∏ i ∈ t, a.get i ∈ FP (Stream'.drop (t.min' hs) a)
hs : s.Nonempty
h : s.erase (s.min' hs) = ∅
⊢ (Stream'.drop (s.min' hs) a).head * ∏ x ∈ s.erase (s.min' hs), a.get x ∈ FP (Stream'.drop (s.min' hs) a)

case H.inr
M : Type u_1
inst✝ : CommMonoid M
a : Stream' M
s : Finset ℕ
ih : ∀ t ⊂ s, ∀ (hs : t.Nonempty), ∏ i ∈ t, a.get i ∈ FP (Stream'.drop (t.min' hs) a)
hs : s.Nonempty
h : (s.erase (s.min' hs)).Nonempty
⊢ (Stream'.drop (s.min' hs) a).head * ∏ x ∈ s.erase (s.min' hs), a.get x ∈ FP (Stream'.drop (s.min' hs) a)
tactic: rcases (s.erase (s.min' hs)).eq_empty_or_nonempty with h | h
Theorem: sup_left_comm
File: Mathlib/Order/Lattice.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : SemilatticeSup α
a✝ b✝ c✝ d a b c : α
⊢ a ⊔ (b ⊔ c) = b ⊔ (a ⊔ c)
state_after: no goals
tactic: rw [← sup_assoc, ← sup_assoc, @sup_comm α _ a]
Theorem: AlgebraicTopology.DoldKan.hσ'_eq'
File: Mathlib/AlgebraicTopology/DoldKan/Homotopies.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
q n a : ℕ
ha : n = a + q
⊢ hσ' q n (n + 1) ⋯ = (-1) ^ a • X.σ ⟨a, ⋯⟩
state_after: no goals
tactic: rw [hσ'_eq ha rfl, eqToHom_refl, comp_id]
Theorem: Set.card_ne_eq
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : Fintype α
a : α
inst✝ : Fintype ↑{x | x ≠ a}
⊢ Fintype.card ↑{x | x ≠ a} = Fintype.card α - 1
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : Fintype α
a : α
inst✝ : Fintype ↑{x | x ≠ a}
this : DecidableEq α
⊢ Fintype.card ↑{x | x ≠ a} = Fintype.card α - 1
tactic: haveI := Classical.decEq α
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : Fintype α
a : α
inst✝ : Fintype ↑{x | x ≠ a}
this : DecidableEq α
⊢ Fintype.card ↑{x | x ≠ a} = Fintype.card α - 1
state_after: no goals
tactic: rw [← toFinset_card, toFinset_setOf, Finset.filter_ne',
    Finset.card_erase_of_mem (Finset.mem_univ _), Finset.card_univ]
Theorem: Module.stableUnderSpecialization_support
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Module.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
M : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : CommRing A
inst✝¹ : Algebra R A
inst✝ : Module A M
⊢ StableUnderSpecialization (support R M)
state_after: R : Type u_1
A : Type u_2
M : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : CommRing A
inst✝¹ : Algebra R A
inst✝ : Module A M
x y : PrimeSpectrum R
e : x ⤳ y
H : x ∈ support R M
⊢ y ∈ support R M
tactic: intros x y e H
state_before: R : Type u_1
A : Type u_2
M : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : CommRing A
inst✝¹ : Algebra R A
inst✝ : Module A M
x y : PrimeSpectrum R
e : x ⤳ y
H : x ∈ support R M
⊢ y ∈ support R M
state_after: R : Type u_1
A : Type u_2
M : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : CommRing A
inst✝¹ : Algebra R A
inst✝ : Module A M
x y : PrimeSpectrum R
e : x ⤳ y
H : ∃ m, (Submodule.span R {m}).annihilator ≤ x.asIdeal
⊢ ∃ m, (Submodule.span R {m}).annihilator ≤ y.asIdeal
tactic: rw [mem_support_iff_exists_annihilator] at H ⊢
state_before: R : Type u_1
A : Type u_2
M : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : CommRing A
inst✝¹ : Algebra R A
inst✝ : Module A M
x y : PrimeSpectrum R
e : x ⤳ y
H : ∃ m, (Submodule.span R {m}).annihilator ≤ x.asIdeal
⊢ ∃ m, (Submodule.span R {m}).annihilator ≤ y.asIdeal
state_after: case intro
R : Type u_1
A : Type u_2
M : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : CommRing A
inst✝¹ : Algebra R A
inst✝ : Module A M
x y : PrimeSpectrum R
e : x ⤳ y
m : M
hm : (Submodule.span R {m}).annihilator ≤ x.asIdeal
⊢ ∃ m, (Submodule.span R {m}).annihilator ≤ y.asIdeal
tactic: obtain ⟨m, hm⟩ := H
state_before: case intro
R : Type u_1
A : Type u_2
M : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : CommRing A
inst✝¹ : Algebra R A
inst✝ : Module A M
x y : PrimeSpectrum R
e : x ⤳ y
m : M
hm : (Submodule.span R {m}).annihilator ≤ x.asIdeal
⊢ ∃ m, (Submodule.span R {m}).annihilator ≤ y.asIdeal
state_after: no goals
tactic: exact ⟨m, hm.trans ((PrimeSpectrum.le_iff_specializes _ _).mpr e)⟩
Theorem: List.disjoint_take_drop
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
m n : Nat
x✝¹ : [].Nodup
x✝ : m ≤ n
⊢ (take m []).Disjoint (drop n [])
state_after: no goals
tactic: simp
state_before: α : Type u_1
m n : Nat
x : α
xs : List α
hl : (x :: xs).Nodup
h : m ≤ n
⊢ (take m (x :: xs)).Disjoint (drop n (x :: xs))
state_after: case succ.zero
α : Type u_1
x : α
xs : List α
hl : (x :: xs).Nodup
n✝ : Nat
h : n✝ + 1 ≤ 0
⊢ ¬x ∈ x :: xs ∧ (take n✝ xs).Disjoint (x :: xs)

case succ.succ
α : Type u_1
x : α
xs : List α
hl : (x :: xs).Nodup
n✝¹ n✝ : Nat
h : n✝¹ + 1 ≤ n✝ + 1
⊢ ¬x ∈ drop n✝ xs ∧ (take n✝¹ xs).Disjoint (drop n✝ xs)
tactic: cases m <;> cases n <;> simp only [disjoint_cons_left, drop, not_mem_nil, disjoint_nil_left,
      take, not_false_eq_true, and_self]
Theorem: Complex.cos_zero
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℂ
⊢ cos 0 = 1
state_after: no goals
tactic: simp [cos]
Theorem: CategoryTheory.Adjunction.Localization.ε_app
File: Mathlib/CategoryTheory/Localization/Adjunction.lean

Proof steps:
state_before: C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_6, u_1} C₁
inst✝⁶ : Category.{u_8, u_2} C₂
inst✝⁵ : Category.{u_5, u_3} D₁
inst✝⁴ : Category.{u_7, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : L₁.IsLocalization W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : L₂.IsLocalization W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
X₁ : C₁
⊢ (ε adj L₁ W₁ L₂ G' F').app (L₁.obj X₁) =
    L₁.map (adj.unit.app X₁) ≫
      (CatCommSq.iso F L₂ L₁ F').hom.app (G.obj X₁) ≫ F'.map ((CatCommSq.iso G L₁ L₂ G').hom.app X₁)
state_after: C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_6, u_1} C₁
inst✝⁶ : Category.{u_8, u_2} C₂
inst✝⁵ : Category.{u_5, u_3} D₁
inst✝⁴ : Category.{u_7, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : L₁.IsLocalization W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : L₂.IsLocalization W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
X₁ : C₁
this : Lifting L₁ W₁ ((G ⋙ F) ⋙ L₁) (G' ⋙ F') := { iso' := CatCommSq.iso'.symm }
⊢ (ε adj L₁ W₁ L₂ G' F').app (L₁.obj X₁) =
    L₁.map (adj.unit.app X₁) ≫
      (CatCommSq.iso F L₂ L₁ F').hom.app (G.obj X₁) ≫ F'.map ((CatCommSq.iso G L₁ L₂ G').hom.app X₁)
tactic: letI : Lifting L₁ W₁ ((G ⋙ F) ⋙ L₁) (G' ⋙ F') :=
    Lifting.mk (CatCommSq.hComp G F L₁ L₂ L₁ G' F').iso'.symm
state_before: C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_6, u_1} C₁
inst✝⁶ : Category.{u_8, u_2} C₂
inst✝⁵ : Category.{u_5, u_3} D₁
inst✝⁴ : Category.{u_7, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : L₁.IsLocalization W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : L₂.IsLocalization W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
X₁ : C₁
this : Lifting L₁ W₁ ((G ⋙ F) ⋙ L₁) (G' ⋙ F') := { iso' := CatCommSq.iso'.symm }
⊢ (ε adj L₁ W₁ L₂ G' F').app (L₁.obj X₁) =
    L₁.map (adj.unit.app X₁) ≫
      (CatCommSq.iso F L₂ L₁ F').hom.app (G.obj X₁) ≫ F'.map ((CatCommSq.iso G L₁ L₂ G').hom.app X₁)
state_after: no goals
tactic: simp only [ε, liftNatTrans_app, Lifting.iso, Iso.symm,
    Functor.id_obj, Functor.comp_obj, Lifting.id_iso', Functor.rightUnitor_hom_app,
      whiskerRight_app, CatCommSq.hComp_iso'_hom_app, id_comp]
Theorem: padicNormE.eq_of_norm_add_lt_right
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z1 z2 : ℚ_[p]
h : ‖z1 + z2‖ < ‖z2‖
hne : ¬‖z1‖ = ‖z2‖
⊢ ‖z1 + z2‖ ≥ ‖z2‖
state_after: p : ℕ
hp : Fact (Nat.Prime p)
z1 z2 : ℚ_[p]
h : ‖z1 + z2‖ < ‖z2‖
hne : ¬‖z1‖ = ‖z2‖
⊢ max ‖z1‖ ‖z2‖ ≥ ‖z2‖
tactic: rw [padicNormE.add_eq_max_of_ne hne]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z1 z2 : ℚ_[p]
h : ‖z1 + z2‖ < ‖z2‖
hne : ¬‖z1‖ = ‖z2‖
⊢ max ‖z1‖ ‖z2‖ ≥ ‖z2‖
state_after: no goals
tactic: apply le_max_right
Theorem: CategoryTheory.Over.over_right
File: Mathlib/CategoryTheory/Comma/Over.lean

Proof steps:
state_before: T : Type u₁
inst✝ : Category.{v₁, u₁} T
X : T
U : Over X
⊢ U.right = { as := PUnit.unit }
state_after: no goals
tactic: simp only
Theorem: Nat.map_swap_divisorsAntidiagonal
File: Mathlib/NumberTheory/Divisors.lean

Proof steps:
state_before: n : ℕ
⊢ map (Equiv.prodComm ℕ ℕ).toEmbedding n.divisorsAntidiagonal = n.divisorsAntidiagonal
state_after: n : ℕ
⊢ Prod.swap ⁻¹' ↑n.divisorsAntidiagonal = ↑n.divisorsAntidiagonal
tactic: rw [← coe_inj, coe_map, Equiv.coe_toEmbedding, Equiv.coe_prodComm,
    Set.image_swap_eq_preimage_swap]
state_before: n : ℕ
⊢ Prod.swap ⁻¹' ↑n.divisorsAntidiagonal = ↑n.divisorsAntidiagonal
state_after: case h
n : ℕ
x✝ : ℕ × ℕ
⊢ x✝ ∈ Prod.swap ⁻¹' ↑n.divisorsAntidiagonal ↔ x✝ ∈ ↑n.divisorsAntidiagonal
tactic: ext
state_before: case h
n : ℕ
x✝ : ℕ × ℕ
⊢ x✝ ∈ Prod.swap ⁻¹' ↑n.divisorsAntidiagonal ↔ x✝ ∈ ↑n.divisorsAntidiagonal
state_after: no goals
tactic: exact swap_mem_divisorsAntidiagonal
Theorem: TopCat.snd_embedding_of_left_embedding
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

Proof steps:
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
H : Embedding ⇑f
g : Y ⟶ S
⊢ Embedding ⇑(pullback.snd f g)
state_after: case h.e'_5
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
H : Embedding ⇑f
g : Y ⟶ S
⊢ ⇑(pullback.snd f g) = ⇑(homeoOfIso (asIso (pullback.snd (𝟙 S) g))) ∘ ⇑(pullback.map f g (𝟙 S) g f (𝟙 Y) (𝟙 S) ⋯ ⋯)
tactic: convert (homeoOfIso (asIso (pullback.snd (𝟙 S) g))).embedding.comp
      (pullback_map_embedding_of_embeddings (i₂ := 𝟙 Y)
        f g (𝟙 S) g H (homeoOfIso (Iso.refl _)).embedding (𝟙 _) rfl (by simp))
state_before: case h.e'_5
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
H : Embedding ⇑f
g : Y ⟶ S
⊢ ⇑(pullback.snd f g) = ⇑(homeoOfIso (asIso (pullback.snd (𝟙 S) g))) ∘ ⇑(pullback.map f g (𝟙 S) g f (𝟙 Y) (𝟙 S) ⋯ ⋯)
state_after: case h.e'_5
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
H : Embedding ⇑f
g : Y ⟶ S
⊢ ⇑(pullback.snd f g) = ⇑(pullback.map f g (𝟙 S) g f (𝟙 Y) (𝟙 S) ⋯ ⋯ ≫ (asIso (pullback.snd (𝟙 S) g)).hom)
tactic: erw [← coe_comp]
state_before: case h.e'_5
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
H : Embedding ⇑f
g : Y ⟶ S
⊢ ⇑(pullback.snd f g) = ⇑(pullback.map f g (𝟙 S) g f (𝟙 Y) (𝟙 S) ⋯ ⋯ ≫ (asIso (pullback.snd (𝟙 S) g)).hom)
state_after: no goals
tactic: simp
Theorem: denomsClearable_zero
File: Mathlib/Algebra/Polynomial/DenomsClearable.lean

Proof steps:
state_before: R : Type u_1
K : Type u_2
inst✝¹ : Semiring R
inst✝ : CommSemiring K
i : R →+* K
a✝ b : R
bi : K
N : ℕ
a : R
bu : bi * i b = 1
⊢ i 0 = i b ^ N * eval (i a * bi) (Polynomial.map i 0)
state_after: no goals
tactic: simp only [eval_zero, RingHom.map_zero, mul_zero, Polynomial.map_zero]