ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Complex.continuous_exp
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

Proof steps:
state_before: z y✝ x✝ : ℝ
x y : ℂ
⊢ dist y x < 1 → dist (cexp y) (cexp x) ≤ 2 * ‖cexp x‖ * dist y x
state_after: case h'.h.e'_4
z y✝ x✝ : ℝ
x y : ℂ
a✝ : ‖y - x‖ < 1
⊢ 2 * ‖cexp x‖ * dist y x = (1 + 1) * ‖cexp x‖ * ‖y - x‖
tactic: convert locally_lipschitz_exp zero_le_one le_rfl x y using 2
state_before: case h'.h.e'_4
z y✝ x✝ : ℝ
x y : ℂ
a✝ : ‖y - x‖ < 1
⊢ 2 * ‖cexp x‖ * dist y x = (1 + 1) * ‖cexp x‖ * ‖y - x‖
state_after: case h'.h.e'_4.e_a.e_a
z y✝ x✝ : ℝ
x y : ℂ
a✝ : ‖y - x‖ < 1
⊢ 2 = 1 + 1
tactic: congr
state_before: case h'.h.e'_4.e_a.e_a
z y✝ x✝ : ℝ
x y : ℂ
a✝ : ‖y - x‖ < 1
⊢ 2 = 1 + 1
state_after: no goals
tactic: ring
Theorem: Complex.mul_conj
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: z : ℂ
⊢ (z * (starRingEnd ℂ) z).re = (↑(normSq z)).re ∧ (z * (starRingEnd ℂ) z).im = (↑(normSq z)).im
state_after: no goals
tactic: simp [normSq, mul_comm, sub_eq_neg_add, add_comm, ofReal']
Theorem: UnitalShelf.act_self_act_eq
File: Mathlib/Algebra/Quandle.lean

Proof steps:
state_before: S : Type u_1
inst✝ : UnitalShelf S
x y : S
⊢ x ◃ x ◃ y = x ◃ y
state_after: S : Type u_1
inst✝ : UnitalShelf S
x y : S
h : x ◃ x ◃ y = (x ◃ 1) ◃ x ◃ y
⊢ x ◃ x ◃ y = x ◃ y
tactic: have h : x ◃ (x ◃ y) = (x ◃ 1) ◃ (x ◃ y) := by rw [act_one]
state_before: S : Type u_1
inst✝ : UnitalShelf S
x y : S
h : x ◃ x ◃ y = (x ◃ 1) ◃ x ◃ y
⊢ x ◃ x ◃ y = x ◃ y
state_after: no goals
tactic: rw [h, ← Shelf.self_distrib, one_act]
Theorem: Finset.mem_shadow_iterate_iff_exists_mem_card_add
File: Mathlib/Combinatorics/SetFamily/Shadow.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ t ∈ ∂ ^[k] 𝒜 ↔ ∃ s ∈ 𝒜, t ⊆ s ∧ s.card = t.card + k
state_after: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t✝ : Finset α
a : α
k r : ℕ
t : Finset α
x✝ : t ∈ 𝒜
hst : t✝ ⊆ t
⊢ (t \ t✝).card = k ↔ t.card = t✝.card + k
tactic: refine mem_shadow_iterate_iff_exists_sdiff.trans <| exists_congr fun t ↦ and_congr_right fun _ ↦
    and_congr_right fun hst ↦ ?_
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t✝ : Finset α
a : α
k r : ℕ
t : Finset α
x✝ : t ∈ 𝒜
hst : t✝ ⊆ t
⊢ (t \ t✝).card = k ↔ t.card = t✝.card + k
state_after: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t✝ : Finset α
a : α
k r : ℕ
t : Finset α
x✝ : t ∈ 𝒜
hst : t✝ ⊆ t
⊢ t✝.card ≤ t.card
tactic: rw [card_sdiff hst, tsub_eq_iff_eq_add_of_le, add_comm]
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t✝ : Finset α
a : α
k r : ℕ
t : Finset α
x✝ : t ∈ 𝒜
hst : t✝ ⊆ t
⊢ t✝.card ≤ t.card
state_after: no goals
tactic: exact card_mono hst
Theorem: Monoid.PushoutI.NormalWord.prod_empty
File: Mathlib/GroupTheory/PushoutI.lean

Proof steps:
state_before: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝⁴ : Monoid K
inst✝³ : (i : ι) → Group (G i)
inst✝² : Group H
φ : (i : ι) → H →* G i
d : Transversal φ
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (G i)
⊢ empty.prod = 1
state_after: no goals
tactic: simp [prod, empty]
Theorem: Ring.multichoose_one_right
File: Mathlib/RingTheory/Binomial.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : AddCommMonoid R
inst✝³ : Pow R ℕ
inst✝² : BinomialRing R
inst✝¹ : MulOneClass R
inst✝ : NatPowAssoc R
r : R
⊢ multichoose r 1 = r
state_after: no goals
tactic: rw [multichoose_one_right', npow_one]
Theorem: Cardinal.ofENat_mul
File: Mathlib/SetTheory/Cardinal/ENat.lean

Proof steps:
state_before: m n : ℕ∞
⊢ ↑(m * n) ∈ Iic ℵ₀
state_after: no goals
tactic: simp
state_before: m n : ℕ∞
⊢ toENat ↑(m * n) = toENat (↑m * ↑n)
state_after: no goals
tactic: simp
Theorem: Polynomial.IsPrimitive.irreducible_of_irreducible_map_of_injective
File: Mathlib/RingTheory/Polynomial/GaussLemma.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
S : Type u_2
inst✝¹ : CommRing S
inst✝ : IsDomain S
φ : R →+* S
hinj : Function.Injective ⇑φ
f : R[X]
hf : f.IsPrimitive
h_irr : Irreducible (map φ f)
⊢ Irreducible f
state_after: case refine_1
R : Type u_1
inst✝² : CommRing R
S : Type u_2
inst✝¹ : CommRing S
inst✝ : IsDomain S
φ : R →+* S
hinj : Function.Injective ⇑φ
f : R[X]
hf : f.IsPrimitive
h_irr : Irreducible (map φ f)
a b : R[X]
h : f = a * b
⊢ IsUnit (map φ a) → IsUnit a

case refine_2
R : Type u_1
inst✝² : CommRing R
S : Type u_2
inst✝¹ : CommRing S
inst✝ : IsDomain S
φ : R →+* S
hinj : Function.Injective ⇑φ
f : R[X]
hf : f.IsPrimitive
h_irr : Irreducible (map φ f)
a b : R[X]
h : f = a * b
⊢ IsUnit (map φ b) → IsUnit b
tactic: refine
    ⟨fun h => h_irr.not_unit (IsUnit.map (mapRingHom φ) h), fun a b h =>
      (h_irr.isUnit_or_isUnit <| by rw [h, Polynomial.map_mul]).imp ?_ ?_⟩
state_before: case refine_1
R : Type u_1
inst✝² : CommRing R
S : Type u_2
inst✝¹ : CommRing S
inst✝ : IsDomain S
φ : R →+* S
hinj : Function.Injective ⇑φ
f : R[X]
hf : f.IsPrimitive
h_irr : Irreducible (map φ f)
a b : R[X]
h : f = a * b
⊢ IsUnit (map φ a) → IsUnit a

case refine_2
R : Type u_1
inst✝² : CommRing R
S : Type u_2
inst✝¹ : CommRing S
inst✝ : IsDomain S
φ : R →+* S
hinj : Function.Injective ⇑φ
f : R[X]
hf : f.IsPrimitive
h_irr : Irreducible (map φ f)
a b : R[X]
h : f = a * b
⊢ IsUnit (map φ b) → IsUnit b
state_after: R : Type u_1
inst✝² : CommRing R
S : Type u_2
inst✝¹ : CommRing S
inst✝ : IsDomain S
φ : R →+* S
hinj : Function.Injective ⇑φ
f : R[X]
hf : f.IsPrimitive
h_irr : Irreducible (map φ f)
a b : R[X]
h : f = a * b
⊢ a ∣ f

R : Type u_1
inst✝² : CommRing R
S : Type u_2
inst✝¹ : CommRing S
inst✝ : IsDomain S
φ : R →+* S
hinj : Function.Injective ⇑φ
f : R[X]
hf : f.IsPrimitive
h_irr : Irreducible (map φ f)
a b : R[X]
h : f = a * b
⊢ b ∣ f
tactic: all_goals apply ((isPrimitive_of_dvd hf _).isUnit_iff_isUnit_map_of_injective hinj).mpr
state_before: R : Type u_1
inst✝² : CommRing R
S : Type u_2
inst✝¹ : CommRing S
inst✝ : IsDomain S
φ : R →+* S
hinj : Function.Injective ⇑φ
f : R[X]
hf : f.IsPrimitive
h_irr : Irreducible (map φ f)
a b : R[X]
h : f = a * b
⊢ a ∣ f

R : Type u_1
inst✝² : CommRing R
S : Type u_2
inst✝¹ : CommRing S
inst✝ : IsDomain S
φ : R →+* S
hinj : Function.Injective ⇑φ
f : R[X]
hf : f.IsPrimitive
h_irr : Irreducible (map φ f)
a b : R[X]
h : f = a * b
⊢ b ∣ f
state_after: no goals
tactic: exacts [Dvd.intro _ h.symm, Dvd.intro_left _ h.symm]
Theorem: CliffordAlgebra.evenOdd_comap_involute
File: Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
n : ZMod 2
⊢ Submodule.comap involute.toLinearMap (evenOdd Q n) = evenOdd Q n
state_after: no goals
tactic: rw [← submodule_map_involute_eq_comap, evenOdd_map_involute]
Theorem: CategoryTheory.Limits.pullback_diagonal_map_snd_fst_fst
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.9082, u_1} C
X Y Z : C
inst✝ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
⊢ (i₁ ≫ snd f i) ≫ i = (i₁ ≫ fst f i) ≫ f
state_after: no goals
tactic: simp [condition]
state_before: C : Type u_1
inst✝¹ : Category.{?u.9082, u_1} C
X Y Z : C
inst✝ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
⊢ (i₂ ≫ snd f i) ≫ i = (i₂ ≫ fst f i) ≫ f
state_after: no goals
tactic: simp [condition]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
X Y Z : C
inst✝ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
⊢ snd (diagonal f) (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i ⋯ ⋯) ≫
      fst (i₁ ≫ snd f i) (i₂ ≫ snd f i) ≫ i₁ ≫ fst f i =
    fst (diagonal f) (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i ⋯ ⋯)
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
X Y Z : C
inst✝ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
⊢ snd (diagonal f) (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i ⋯ ⋯) ≫
      fst (i₁ ≫ snd f i) (i₂ ≫ snd f i) ≫ i₁ ≫ fst f i =
    fst (diagonal f) (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i ⋯ ⋯) ≫ 𝟙 X
tactic: conv_rhs => rw [← Category.comp_id (pullback.fst _ _)]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
X Y Z : C
inst✝ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
⊢ snd (diagonal f) (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i ⋯ ⋯) ≫
      fst (i₁ ≫ snd f i) (i₂ ≫ snd f i) ≫ i₁ ≫ fst f i =
    fst (diagonal f) (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i ⋯ ⋯) ≫ 𝟙 X
state_after: no goals
tactic: rw [← diagonal_fst f, pullback.condition_assoc, pullback.lift_fst]
Theorem: LucasLehmer.X.coe_mul
File: Mathlib/NumberTheory/LucasLehmer.lean

Proof steps:
state_before: q : ℕ+
n m : ℤ
⊢ ↑(n * m) = ↑n * ↑m
state_after: no goals
tactic: ext <;> simp
Theorem: FractionalIdeal.count_zpow
File: Mathlib/RingTheory/DedekindDomain/Factorization.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
n : ℤ
I : FractionalIdeal R⁰ K
⊢ count K v (I ^ n) = n * count K v I
state_after: case ofNat
R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
I : FractionalIdeal R⁰ K
n : ℕ
⊢ count K v (I ^ ofNat n) = ofNat n * count K v I

case negSucc
R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
I : FractionalIdeal R⁰ K
a✝ : ℕ
⊢ count K v (I ^ -[a✝+1]) = -[a✝+1] * count K v I
tactic: cases' n with n
Theorem: WeierstrassCurve.Jacobian.map_negAddY
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝² : CommRing R
W' : Jacobian R
F : Type v
inst✝¹ : Field F
W : Jacobian F
S : Type u_1
inst✝ : CommRing S
f : R →+* S
P Q : Fin 3 → R
⊢ negAddY (map W' f) (⇑f ∘ P) (⇑f ∘ Q) = f (W'.negAddY P Q)
state_after: no goals
tactic: simp [negAddY]
Theorem: List.filter_true
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
⊢ filter (fun x => true) l = l
state_after: no goals
tactic: induction l <;> simp [*, filter]
Theorem: AddSubmonoid.LocalizationMap.sec_spec'
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
z : N
⊢ f.toMap (f.sec z).1 = f.toMap ↑(f.sec z).2 * z
state_after: no goals
tactic: rw [mul_comm, sec_spec]
Theorem: Oscillation.eq_zero_iff_continuousAt
File: Mathlib/Analysis/Oscillation.lean

Proof steps:
state_before: E : Type u
F : Type v
inst✝¹ : PseudoEMetricSpace F
inst✝ : TopologicalSpace E
f : E → F
x : E
⊢ oscillation f x = 0 ↔ ContinuousAt f x
state_after: E : Type u
F : Type v
inst✝¹ : PseudoEMetricSpace F
inst✝ : TopologicalSpace E
f : E → F
x : E
⊢ oscillationWithin f univ x = 0 ↔ ContinuousWithinAt f univ x
tactic: rw [← oscillationWithin_univ_eq_oscillation, ← continuousWithinAt_univ f x]
state_before: E : Type u
F : Type v
inst✝¹ : PseudoEMetricSpace F
inst✝ : TopologicalSpace E
f : E → F
x : E
⊢ oscillationWithin f univ x = 0 ↔ ContinuousWithinAt f univ x
state_after: no goals
tactic: exact OscillationWithin.eq_zero_iff_continuousWithinAt f (mem_univ x)
Theorem: Real.rpow_add'
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x✝ y✝ z✝ w x y z : ℝ
hx : 0 ≤ x
h : y + z ≠ 0
⊢ x ^ (y + z) = x ^ y * x ^ z
state_after: case inl
x y✝ z✝ w y z : ℝ
h : y + z ≠ 0
hx : 0 ≤ 0
⊢ 0 ^ (y + z) = 0 ^ y * 0 ^ z

case inr
x✝ y✝ z✝ w x y z : ℝ
hx : 0 ≤ x
h : y + z ≠ 0
pos : 0 < x
⊢ x ^ (y + z) = x ^ y * x ^ z
tactic: rcases hx.eq_or_lt with (rfl | pos)
Theorem: SetTheory.PGame.zero_le
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x : PGame
⊢ 0 ≤ x ↔ ∀ (j : x.RightMoves), ∃ i, 0 ≤ (x.moveRight j).moveLeft i
state_after: xl xr : Type u
x : PGame
⊢ ((∀ (i : LeftMoves 0), (∃ i', moveLeft 0 i ≤ x.moveLeft i') ∨ ∃ j, (moveLeft 0 i).moveRight j ≤ x) ∧
      ∀ (j : x.RightMoves), (∃ i, 0 ≤ (x.moveRight j).moveLeft i) ∨ ∃ j', moveRight 0 j' ≤ x.moveRight j) ↔
    ∀ (j : x.RightMoves), ∃ i, 0 ≤ (x.moveRight j).moveLeft i
tactic: rw [le_def]
state_before: xl xr : Type u
x : PGame
⊢ ((∀ (i : LeftMoves 0), (∃ i', moveLeft 0 i ≤ x.moveLeft i') ∨ ∃ j, (moveLeft 0 i).moveRight j ≤ x) ∧
      ∀ (j : x.RightMoves), (∃ i, 0 ≤ (x.moveRight j).moveLeft i) ∨ ∃ j', moveRight 0 j' ≤ x.moveRight j) ↔
    ∀ (j : x.RightMoves), ∃ i, 0 ≤ (x.moveRight j).moveLeft i
state_after: no goals
tactic: simp
Theorem: Rat.cast_mkRat_of_ne_zero
File: Mathlib/Data/Rat/Cast/Defs.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝ : DivisionRing α
p q : ℚ
a : ℤ
b : ℕ
hb : ↑b ≠ 0
⊢ ↑(mkRat a b) = ↑a / ↑b
state_after: case b0
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝ : DivisionRing α
p q : ℚ
a : ℤ
b : ℕ
hb : ↑b ≠ 0
⊢ ↑↑b ≠ 0
tactic: rw [Rat.mkRat_eq_divInt, cast_divInt_of_ne_zero, Int.cast_natCast]
state_before: case b0
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝ : DivisionRing α
p q : ℚ
a : ℤ
b : ℕ
hb : ↑b ≠ 0
⊢ ↑↑b ≠ 0
state_after: no goals
tactic: rwa [Int.cast_natCast]
Theorem: Finset.not_mem_sdiff_of_mem_right
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
h : a ∈ t
⊢ a ∉ s \ t
state_after: no goals
tactic: simp only [mem_sdiff, h, not_true, not_false_iff, and_false_iff]
Theorem: Fintype.sum_piFinset_apply
File: Mathlib/Algebra/Module/BigOperators.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
R : Type u_5
M : Type u_6
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
inst✝ : AddCommMonoid α
f : κ → α
s : Finset κ
i : ι
⊢ ∑ g ∈ piFinset fun x => s, f (g i) = s.card ^ (card ι - 1) • ∑ b ∈ s, f b
state_after: no goals
tactic: classical
  rw [Finset.sum_comp]
  simp only [eval_image_piFinset_const, card_filter_piFinset_const s, ite_smul, zero_smul, smul_sum,
    sum_ite_mem, inter_self]
Theorem: DvdNotUnit.isUnit_of_irreducible_right
File: Mathlib/Algebra/Associated/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoidWithZero α
p q : α
h : DvdNotUnit p q
hq : Irreducible q
⊢ IsUnit p
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoidWithZero α
p q : α
hq : Irreducible q
left✝ : p ≠ 0
x : α
hx : ¬IsUnit x
hx' : q = p * x
⊢ IsUnit p
tactic: obtain ⟨_, x, hx, hx'⟩ := h
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoidWithZero α
p q : α
hq : Irreducible q
left✝ : p ≠ 0
x : α
hx : ¬IsUnit x
hx' : q = p * x
⊢ IsUnit p
state_after: no goals
tactic: exact Or.resolve_right ((irreducible_iff.1 hq).right p x hx') hx
Theorem: CategoryTheory.IsPullback.of_id_snd
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
⊢ f ≫ 𝟙 Z = 𝟙 X ≫ f
state_after: no goals
tactic: simp
Theorem: EReal.continuousAt_add
File: Mathlib/Topology/Instances/EReal.lean

Proof steps:
state_before: α : Type u_1
inst✝ : TopologicalSpace α
p : EReal × EReal
h : p.1 ≠ ⊤ ∨ p.2 ≠ ⊥
h' : p.1 ≠ ⊥ ∨ p.2 ≠ ⊤
⊢ ContinuousAt (fun p => p.1 + p.2) p
state_after: case mk
α : Type u_1
inst✝ : TopologicalSpace α
x y : EReal
h : (x, y).1 ≠ ⊤ ∨ (x, y).2 ≠ ⊥
h' : (x, y).1 ≠ ⊥ ∨ (x, y).2 ≠ ⊤
⊢ ContinuousAt (fun p => p.1 + p.2) (x, y)
tactic: rcases p with ⟨x, y⟩
state_before: case mk
α : Type u_1
inst✝ : TopologicalSpace α
x y : EReal
h : (x, y).1 ≠ ⊤ ∨ (x, y).2 ≠ ⊥
h' : (x, y).1 ≠ ⊥ ∨ (x, y).2 ≠ ⊤
⊢ ContinuousAt (fun p => p.1 + p.2) (x, y)
state_after: case mk.h_bot.h_bot
α : Type u_1
inst✝ : TopologicalSpace α
h : (⊥, ⊥).1 ≠ ⊤ ∨ (⊥, ⊥).2 ≠ ⊥
h' : (⊥, ⊥).1 ≠ ⊥ ∨ (⊥, ⊥).2 ≠ ⊤
⊢ ContinuousAt (fun p => p.1 + p.2) (⊥, ⊥)

case mk.h_bot.h_real
α : Type u_1
inst✝ : TopologicalSpace α
a✝ : ℝ
h : (⊥, ↑a✝).1 ≠ ⊤ ∨ (⊥, ↑a✝).2 ≠ ⊥
h' : (⊥, ↑a✝).1 ≠ ⊥ ∨ (⊥, ↑a✝).2 ≠ ⊤
⊢ ContinuousAt (fun p => p.1 + p.2) (⊥, ↑a✝)

case mk.h_bot.h_top
α : Type u_1
inst✝ : TopologicalSpace α
h : (⊥, ⊤).1 ≠ ⊤ ∨ (⊥, ⊤).2 ≠ ⊥
h' : (⊥, ⊤).1 ≠ ⊥ ∨ (⊥, ⊤).2 ≠ ⊤
⊢ ContinuousAt (fun p => p.1 + p.2) (⊥, ⊤)

case mk.h_real.h_bot
α : Type u_1
inst✝ : TopologicalSpace α
a✝ : ℝ
h : (↑a✝, ⊥).1 ≠ ⊤ ∨ (↑a✝, ⊥).2 ≠ ⊥
h' : (↑a✝, ⊥).1 ≠ ⊥ ∨ (↑a✝, ⊥).2 ≠ ⊤
⊢ ContinuousAt (fun p => p.1 + p.2) (↑a✝, ⊥)

case mk.h_real.h_real
α : Type u_1
inst✝ : TopologicalSpace α
a✝¹ a✝ : ℝ
h : (↑a✝¹, ↑a✝).1 ≠ ⊤ ∨ (↑a✝¹, ↑a✝).2 ≠ ⊥
h' : (↑a✝¹, ↑a✝).1 ≠ ⊥ ∨ (↑a✝¹, ↑a✝).2 ≠ ⊤
⊢ ContinuousAt (fun p => p.1 + p.2) (↑a✝¹, ↑a✝)

case mk.h_real.h_top
α : Type u_1
inst✝ : TopologicalSpace α
a✝ : ℝ
h : (↑a✝, ⊤).1 ≠ ⊤ ∨ (↑a✝, ⊤).2 ≠ ⊥
h' : (↑a✝, ⊤).1 ≠ ⊥ ∨ (↑a✝, ⊤).2 ≠ ⊤
⊢ ContinuousAt (fun p => p.1 + p.2) (↑a✝, ⊤)

case mk.h_top.h_bot
α : Type u_1
inst✝ : TopologicalSpace α
h : (⊤, ⊥).1 ≠ ⊤ ∨ (⊤, ⊥).2 ≠ ⊥
h' : (⊤, ⊥).1 ≠ ⊥ ∨ (⊤, ⊥).2 ≠ ⊤
⊢ ContinuousAt (fun p => p.1 + p.2) (⊤, ⊥)

case mk.h_top.h_real
α : Type u_1
inst✝ : TopologicalSpace α
a✝ : ℝ
h : (⊤, ↑a✝).1 ≠ ⊤ ∨ (⊤, ↑a✝).2 ≠ ⊥
h' : (⊤, ↑a✝).1 ≠ ⊥ ∨ (⊤, ↑a✝).2 ≠ ⊤
⊢ ContinuousAt (fun p => p.1 + p.2) (⊤, ↑a✝)

case mk.h_top.h_top
α : Type u_1
inst✝ : TopologicalSpace α
h : (⊤, ⊤).1 ≠ ⊤ ∨ (⊤, ⊤).2 ≠ ⊥
h' : (⊤, ⊤).1 ≠ ⊥ ∨ (⊤, ⊤).2 ≠ ⊤
⊢ ContinuousAt (fun p => p.1 + p.2) (⊤, ⊤)
tactic: induction x <;> induction y
Theorem: CategoryTheory.CosimplicialObject.δ_comp_δ_self
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
⊢ X.δ i ≫ X.δ i.castSucc = X.δ i ≫ X.δ i.succ
state_after: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
⊢ X.map (SimplexCategory.δ i) ≫ X.map (SimplexCategory.δ i.castSucc) =
    X.map (SimplexCategory.δ i) ≫ X.map (SimplexCategory.δ i.succ)
tactic: dsimp [δ]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
⊢ X.map (SimplexCategory.δ i) ≫ X.map (SimplexCategory.δ i.castSucc) =
    X.map (SimplexCategory.δ i) ≫ X.map (SimplexCategory.δ i.succ)
state_after: no goals
tactic: simp only [← X.map_comp, SimplexCategory.δ_comp_δ_self]
Theorem: LocalRing.map_mkQ_eq
File: Mathlib/RingTheory/LocalRing/Module.lean

Proof steps:
state_before: R : Type u_1
S : Type ?u.26011
inst✝⁹ : CommRing R
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
inst✝⁶ : LocalRing R
M : Type u_2
N : Type ?u.26476
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R M
inst✝² : Module R N
P : Type ?u.27616
inst✝¹ : AddCommGroup P
inst✝ : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
hg : Surjective ⇑g
h✝ : Exact ⇑f ⇑g
N₁ N₂ : Submodule R M
h : N₁ ≤ N₂
h' : N₂.FG
⊢ Submodule.map (𝔪 • N₂).mkQ N₁ = Submodule.map (𝔪 • N₂).mkQ N₂ ↔ N₁ = N₂
state_after: case mp
R : Type u_1
S : Type ?u.26011
inst✝⁹ : CommRing R
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
inst✝⁶ : LocalRing R
M : Type u_2
N : Type ?u.26476
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R M
inst✝² : Module R N
P : Type ?u.27616
inst✝¹ : AddCommGroup P
inst✝ : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
hg : Surjective ⇑g
h✝ : Exact ⇑f ⇑g
N₁ N₂ : Submodule R M
h : N₁ ≤ N₂
h' : N₂.FG
⊢ Submodule.map (𝔪 • N₂).mkQ N₁ = Submodule.map (𝔪 • N₂).mkQ N₂ → N₁ = N₂

case mpr
R : Type u_1
S : Type ?u.26011
inst✝⁹ : CommRing R
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
inst✝⁶ : LocalRing R
M : Type u_2
N : Type ?u.26476
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R M
inst✝² : Module R N
P : Type ?u.27616
inst✝¹ : AddCommGroup P
inst✝ : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
hg : Surjective ⇑g
h✝ : Exact ⇑f ⇑g
N₁ N₂ : Submodule R M
h : N₁ ≤ N₂
h' : N₂.FG
⊢ N₁ = N₂ → Submodule.map (𝔪 • N₂).mkQ N₁ = Submodule.map (𝔪 • N₂).mkQ N₂
tactic: constructor
Theorem: CategoryTheory.Limits.limit_map_limitObjIsoLimitCompEvaluation_hom
File: Mathlib/CategoryTheory/Limits/FunctorCategory.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasLimitsOfShape J C
i j : K
F : J ⥤ K ⥤ C
f : i ⟶ j
⊢ (limit F).map f ≫ (limitObjIsoLimitCompEvaluation F j).hom =
    (limitObjIsoLimitCompEvaluation F i).hom ≫ limMap (whiskerLeft F ((evaluation K C).map f))
state_after: case w
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasLimitsOfShape J C
i j : K
F : J ⥤ K ⥤ C
f : i ⟶ j
j✝ : J
⊢ ((limit F).map f ≫ (limitObjIsoLimitCompEvaluation F j).hom) ≫ limit.π (F ⋙ (evaluation K C).obj j) j✝ =
    ((limitObjIsoLimitCompEvaluation F i).hom ≫ limMap (whiskerLeft F ((evaluation K C).map f))) ≫
      limit.π (F ⋙ (evaluation K C).obj j) j✝
tactic: ext
state_before: case w
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasLimitsOfShape J C
i j : K
F : J ⥤ K ⥤ C
f : i ⟶ j
j✝ : J
⊢ ((limit F).map f ≫ (limitObjIsoLimitCompEvaluation F j).hom) ≫ limit.π (F ⋙ (evaluation K C).obj j) j✝ =
    ((limitObjIsoLimitCompEvaluation F i).hom ≫ limMap (whiskerLeft F ((evaluation K C).map f))) ≫
      limit.π (F ⋙ (evaluation K C).obj j) j✝
state_after: no goals
tactic: simp
Theorem: Equiv.Perm.support_cycleOf_nonempty
File: Mathlib/GroupTheory/Perm/Cycle/Factors.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝³ : DecidableRel f.SameCycle
inst✝² : DecidableRel g.SameCycle
inst✝¹ : DecidableEq α
inst✝ : Fintype α
⊢ (f.cycleOf x).support.Nonempty ↔ f x ≠ x
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝³ : DecidableRel f.SameCycle
inst✝² : DecidableRel g.SameCycle
inst✝¹ : DecidableEq α
inst✝ : Fintype α
⊢ Nat.succ 0 ≤ (f.cycleOf x).support.card ↔ 2 ≤ (f.cycleOf x).support.card
tactic: rw [← two_le_card_support_cycleOf_iff, ← card_pos, ← Nat.succ_le_iff]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝³ : DecidableRel f.SameCycle
inst✝² : DecidableRel g.SameCycle
inst✝¹ : DecidableEq α
inst✝ : Fintype α
⊢ Nat.succ 0 ≤ (f.cycleOf x).support.card ↔ 2 ≤ (f.cycleOf x).support.card
state_after: no goals
tactic: exact ⟨fun h => Or.resolve_left h.eq_or_lt (card_support_ne_one _).symm, zero_lt_two.trans_le⟩
Theorem: OreLocalization.universalHom_commutes
File: Mathlib/RingTheory/OreLocalization/Ring.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : Semiring R
S : Submonoid R
inst✝³ : OreSet S
X : Type u_2
inst✝² : AddCommMonoid X
inst✝¹ : Module R X
T : Type u_3
inst✝ : Semiring T
f : R →+* T
fS : ↥S →* Tˣ
hf : ∀ (s : ↥S), f ↑s = ↑(fS s)
r : R
⊢ (universalHom f fS hf) (numeratorHom r) = f r
state_after: no goals
tactic: simp [numeratorHom_apply, universalHom_apply]
Theorem: Mathlib.Meta.NormNum.jacobiSymNat.one_left
File: Mathlib/Tactic/NormNum/LegendreSymbol.lean

Proof steps:
state_before: b : ℕ
⊢ jacobiSymNat 1 b = 1
state_after: no goals
tactic: rw [jacobiSymNat, Nat.cast_one, jacobiSym.one_left]
Theorem: Finset.preimage_compl
File: Mathlib/Data/Finset/Preimage.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝³ : DecidableEq α
inst✝² : DecidableEq β
inst✝¹ : Fintype α
inst✝ : Fintype β
f : α → β
s : Finset β
hf : Injective f
⊢ ↑(sᶜ.preimage f ⋯) = ↑(s.preimage f ⋯)ᶜ
state_after: no goals
tactic: simp
Theorem: dist_ne_zero
File: Mathlib/Topology/MetricSpace/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
γ : Type w
inst✝ : MetricSpace γ
x y : γ
⊢ dist x y ≠ 0 ↔ x ≠ y
state_after: no goals
tactic: simpa only [not_iff_not] using dist_eq_zero