ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.ShortComplex.leftHomologyIso_inv_naturality
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ✝ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
φ : S₁ ⟶ S₂
⊢ S₁.leftHomologyIso.inv ≫ leftHomologyMap φ = homologyMap φ ≫ S₂.leftHomologyIso.inv
state_after: no goals
tactic: simpa only [LeftHomologyData.homologyIso_leftHomologyData, Iso.symm_inv] using
    LeftHomologyData.leftHomologyIso_hom_naturality φ S₁.leftHomologyData S₂.leftHomologyData
Theorem: MonotoneOn.congr
File: Mathlib/Data/Set/Function.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s : Set α
f₁ f₂ : α → β
inst✝¹ : Preorder α
inst✝ : Preorder β
h₁ : MonotoneOn f₁ s
h : EqOn f₁ f₂ s
⊢ MonotoneOn f₂ s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s : Set α
f₁ f₂ : α → β
inst✝¹ : Preorder α
inst✝ : Preorder β
h₁ : MonotoneOn f₁ s
h : EqOn f₁ f₂ s
a : α
ha : a ∈ s
b : α
hb : b ∈ s
hab : a ≤ b
⊢ f₂ a ≤ f₂ b
tactic: intro a ha b hb hab
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s : Set α
f₁ f₂ : α → β
inst✝¹ : Preorder α
inst✝ : Preorder β
h₁ : MonotoneOn f₁ s
h : EqOn f₁ f₂ s
a : α
ha : a ∈ s
b : α
hb : b ∈ s
hab : a ≤ b
⊢ f₂ a ≤ f₂ b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s : Set α
f₁ f₂ : α → β
inst✝¹ : Preorder α
inst✝ : Preorder β
h₁ : MonotoneOn f₁ s
h : EqOn f₁ f₂ s
a : α
ha : a ∈ s
b : α
hb : b ∈ s
hab : a ≤ b
⊢ f₁ a ≤ f₁ b
tactic: rw [← h ha, ← h hb]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s : Set α
f₁ f₂ : α → β
inst✝¹ : Preorder α
inst✝ : Preorder β
h₁ : MonotoneOn f₁ s
h : EqOn f₁ f₂ s
a : α
ha : a ∈ s
b : α
hb : b ∈ s
hab : a ≤ b
⊢ f₁ a ≤ f₁ b
state_after: no goals
tactic: exact h₁ ha hb hab
Theorem: FloorRing.exists_prime_mul_pow_lt_factorial
File: Mathlib/Algebra/Order/Floor/Prime.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : LinearOrderedRing K
inst✝ : FloorRing K
n : ℕ
a c : K
⊢ ∃ p > n, Nat.Prime p ∧ a * c ^ p < ↑(p - 1)!
state_after: case intro.intro.intro
K : Type u_1
inst✝¹ : LinearOrderedRing K
inst✝ : FloorRing K
n : ℕ
a c : K
p : ℕ
pn : p > n
pp : Nat.Prime p
h : ⌈|a|⌉.natAbs * ⌈|c|⌉.natAbs ^ p < (p - 1)!
⊢ ∃ p > n, Nat.Prime p ∧ a * c ^ p < ↑(p - 1)!
tactic: obtain ⟨p, pn, pp, h⟩ := n.exists_prime_mul_pow_lt_factorial ⌈|a|⌉.natAbs ⌈|c|⌉.natAbs
state_before: case intro.intro.intro
K : Type u_1
inst✝¹ : LinearOrderedRing K
inst✝ : FloorRing K
n : ℕ
a c : K
p : ℕ
pn : p > n
pp : Nat.Prime p
h : ⌈|a|⌉.natAbs * ⌈|c|⌉.natAbs ^ p < (p - 1)!
⊢ ∃ p > n, Nat.Prime p ∧ a * c ^ p < ↑(p - 1)!
state_after: case right
K : Type u_1
inst✝¹ : LinearOrderedRing K
inst✝ : FloorRing K
n : ℕ
a c : K
p : ℕ
pn : p > n
pp : Nat.Prime p
h : ⌈|a|⌉.natAbs * ⌈|c|⌉.natAbs ^ p < (p - 1)!
⊢ a * c ^ p < ↑(p - 1)!
tactic: use p, pn, pp
state_before: case right
K : Type u_1
inst✝¹ : LinearOrderedRing K
inst✝ : FloorRing K
n : ℕ
a c : K
p : ℕ
pn : p > n
pp : Nat.Prime p
h : ⌈|a|⌉.natAbs * ⌈|c|⌉.natAbs ^ p < (p - 1)!
⊢ a * c ^ p < ↑(p - 1)!
state_after: case right.calc_1
K : Type u_1
inst✝¹ : LinearOrderedRing K
inst✝ : FloorRing K
n : ℕ
a c : K
p : ℕ
pn : p > n
pp : Nat.Prime p
h : ⌈|a|⌉.natAbs * ⌈|c|⌉.natAbs ^ p < (p - 1)!
⊢ |a * c ^ p| ≤ ↑⌈|a|⌉ * ↑⌈|c|⌉ ^ p

case right.calc_2
K : Type u_1
inst✝¹ : LinearOrderedRing K
inst✝ : FloorRing K
n : ℕ
a c : K
p : ℕ
pn : p > n
pp : Nat.Prime p
h : ⌈|a|⌉.natAbs * ⌈|c|⌉.natAbs ^ p < (p - 1)!
⊢ ↑⌈|a|⌉ * ↑⌈|c|⌉ ^ p = ↑(⌈|a|⌉.natAbs * ⌈|c|⌉.natAbs ^ p)
tactic: calc a * c ^ p
    _ ≤ |a * c ^ p| := le_abs_self _
    _ ≤ ⌈|a|⌉ * (⌈|c|⌉ : K) ^ p := ?_
    _ = ↑(Int.natAbs ⌈|a|⌉ * Int.natAbs ⌈|c|⌉ ^ p) := ?_
    _ < ↑(p - 1)! := Nat.cast_lt.mpr h
Theorem: CategoryTheory.OplaxFunctor.bicategory_leftUnitor_hom_app
File: Mathlib/CategoryTheory/Bicategory/FunctorBicategory.lean

Proof steps:
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I a b c : OplaxFunctor B C
f g : a ⟶ b
h i : b ⟶ c
η : f ⟶ g
θ : h ⟶ i
⊢ (fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) f h i θ ≫
      (fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η i =
    (fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η h ≫
      (fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) g h i θ
state_after: case w
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I a b c : OplaxFunctor B C
f g : a ⟶ b
h i : b ⟶ c
η : f ⟶ g
θ : h ⟶ i
b✝ : B
⊢ ((fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) f h i θ ≫
          (fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η i).app
      b✝ =
    ((fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η h ≫
          (fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) g h i θ).app
      b✝
tactic: ext
state_before: case w
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I a b c : OplaxFunctor B C
f g : a ⟶ b
h i : b ⟶ c
η : f ⟶ g
θ : h ⟶ i
b✝ : B
⊢ ((fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) f h i θ ≫
          (fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η i).app
      b✝ =
    ((fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η h ≫
          (fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) g h i θ).app
      b✝
state_after: no goals
tactic: exact whisker_exchange _ _
Theorem: AddSubmonoid.fg_iff_mul_fg
File: Mathlib/GroupTheory/Finiteness.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
inst✝¹ : Monoid M
inst✝ : AddMonoid N
P : AddSubmonoid N
⊢ P.FG ↔ (toSubmonoid P).FG
state_after: no goals
tactic: convert (Submonoid.fg_iff_add_fg (toSubmonoid P)).symm
Theorem: Substring.Valid.bsize
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: x✝ : Substring
h✝ : x✝.Valid
l m r : List Char
h : ValidFor l m r x✝
⊢ x✝.bsize = utf8Len x✝.toString.data
state_after: no goals
tactic: simp [h.bsize, h.toString]
Theorem: MeasureTheory.withDensity_one
File: Mathlib/MeasureTheory/Measure/WithDensity.lean

Proof steps:
state_before: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
⊢ μ.withDensity 1 = μ
state_after: case h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
s : Set α
hs : MeasurableSet s
⊢ (μ.withDensity 1) s = μ s
tactic: ext1 s hs
state_before: case h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
s : Set α
hs : MeasurableSet s
⊢ (μ.withDensity 1) s = μ s
state_after: no goals
tactic: simp [withDensity_apply _ hs]
Theorem: SetTheory.PGame.isOption_neg
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x y : PGame
⊢ x.IsOption (-y) ↔ (-x).IsOption y
state_after: xl xr : Type u
x y : PGame
⊢ ((∃ i, x = (-y).moveRight i) ∨ ∃ i, x = (-y).moveLeft i) ↔ (∃ i, -x = y.moveLeft i) ∨ ∃ i, -x = y.moveRight i
tactic: rw [isOption_iff, isOption_iff, or_comm]
state_before: xl xr : Type u
x y : PGame
⊢ ((∃ i, x = (-y).moveRight i) ∨ ∃ i, x = (-y).moveLeft i) ↔ (∃ i, -x = y.moveLeft i) ∨ ∃ i, -x = y.moveRight i
state_after: case mk
xl xr : Type u
x : PGame
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ ((∃ i, x = (-mk α✝ β✝ a✝¹ a✝).moveRight i) ∨ ∃ i, x = (-mk α✝ β✝ a✝¹ a✝).moveLeft i) ↔
    (∃ i, -x = (mk α✝ β✝ a✝¹ a✝).moveLeft i) ∨ ∃ i, -x = (mk α✝ β✝ a✝¹ a✝).moveRight i
tactic: cases y
Theorem: Function.Involutive.iterate_eq_self
File: Mathlib/Algebra/Ring/Parity.lean

Proof steps:
state_before: F : Type u_1
α✝ : Type u_2
β : Type u_3
R : Type u_4
α : Type u_5
f : α → α
n : ℕ
hf : Involutive f
hne : f ≠ id
H : f^[n] = f
hn : Even n
⊢ f = id
state_after: no goals
tactic: rwa [hf.iterate_even hn, eq_comm] at H
Theorem: Set.iUnion_Ioc_right
File: Mathlib/Order/Interval/Set/Disjoint.lean

Proof steps:
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : Preorder α
a✝ b c a : α
⊢ ⋃ b, Ioc a b = Ioi a
state_after: no goals
tactic: simp only [← Ioi_inter_Iic, ← inter_iUnion, iUnion_Iic, inter_univ]
Theorem: Filter.mem_iInf_of_finite
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α✝ : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α✝
s✝ t : Set α✝
ι : Type u_2
inst✝ : Finite ι
α : Type u_3
f : ι → Filter α
s : Set α
⊢ s ∈ ⨅ i, f i ↔ ∃ t, (∀ (i : ι), t i ∈ f i) ∧ s = ⋂ i, t i
state_after: α✝ : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α✝
s✝ t : Set α✝
ι : Type u_2
inst✝ : Finite ι
α : Type u_3
f : ι → Filter α
s : Set α
⊢ (∃ t, (∀ (i : ι), t i ∈ f i) ∧ s = ⋂ i, t i) → s ∈ ⨅ i, f i
tactic: refine ⟨exists_iInter_of_mem_iInf, ?_⟩
state_before: α✝ : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α✝
s✝ t : Set α✝
ι : Type u_2
inst✝ : Finite ι
α : Type u_3
f : ι → Filter α
s : Set α
⊢ (∃ t, (∀ (i : ι), t i ∈ f i) ∧ s = ⋂ i, t i) → s ∈ ⨅ i, f i
state_after: case intro.intro
α✝ : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α✝
s t✝ : Set α✝
ι : Type u_2
inst✝ : Finite ι
α : Type u_3
f : ι → Filter α
t : ι → Set α
ht : ∀ (i : ι), t i ∈ f i
⊢ ⋂ i, t i ∈ ⨅ i, f i
tactic: rintro ⟨t, ht, rfl⟩
state_before: case intro.intro
α✝ : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α✝
s t✝ : Set α✝
ι : Type u_2
inst✝ : Finite ι
α : Type u_3
f : ι → Filter α
t : ι → Set α
ht : ∀ (i : ι), t i ∈ f i
⊢ ⋂ i, t i ∈ ⨅ i, f i
state_after: no goals
tactic: exact iInter_mem.2 fun i => mem_iInf_of_mem i (ht i)
Theorem: CategoryTheory.GrothendieckTopology.mem_over_iff
File: Mathlib/CategoryTheory/Sites/Over.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
X : C
Y : Over X
S : Sieve Y
⊢ S ∈ (J.over X).sieves Y ↔ (Sieve.overEquiv Y) S ∈ J.sieves Y.left
state_after: no goals
tactic: rfl
Theorem: Complex.sin_conj
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℂ
⊢ sin ((starRingEnd ℂ) x) = (starRingEnd ℂ) (sin x)
state_after: no goals
tactic: rw [← mul_left_inj' I_ne_zero, ← sinh_mul_I, ← conj_neg_I, ← RingHom.map_mul, ← RingHom.map_mul,
    sinh_conj, mul_neg, sinh_neg, sinh_mul_I, mul_neg]
Theorem: Function.minimalPeriod_eq_one_iff_isFixedPt
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
⊢ minimalPeriod f x = 1 ↔ IsFixedPt f x
state_after: case refine_1
α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
h : minimalPeriod f x = 1
⊢ IsFixedPt f x

case refine_2
α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
h : IsFixedPt f x
⊢ minimalPeriod f x = 1
tactic: refine ⟨fun h => ?_, fun h => ?_⟩
Theorem: Submodule.disjoint_iff_comap_eq_bot
File: Mathlib/Algebra/Module/Submodule/Map.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring R₂
inst✝⁹ : Semiring R₃
inst✝⁸ : AddCommMonoid M
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
inst✝⁵ : Module R M
inst✝⁴ : Module R₂ M₂
inst✝³ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
p✝ p' : Submodule R M
q✝ q' : Submodule R₂ M₂
x : M
F : Type u_9
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
p q : Submodule R M
⊢ Disjoint p q ↔ comap p.subtype q = ⊥
state_after: no goals
tactic: rw [← (map_injective_of_injective (show Injective p.subtype from Subtype.coe_injective)).eq_iff,
    map_comap_subtype, map_bot, disjoint_iff]
Theorem: IsOfFinOrder.apply
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Monoid G
a b x✝ y : G
n m : ℕ
η : Type u_6
Gs : η → Type u_7
inst✝ : (i : η) → Monoid (Gs i)
x : (i : η) → Gs i
h : IsOfFinOrder x
⊢ ∀ (i : η), IsOfFinOrder (x i)
state_after: case intro.intro
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Monoid G
a b x✝ y : G
n✝ m : ℕ
η : Type u_6
Gs : η → Type u_7
inst✝ : (i : η) → Monoid (Gs i)
x : (i : η) → Gs i
h : IsOfFinOrder x
n : ℕ
npos : 0 < n
hn : x ^ n = 1
⊢ ∀ (i : η), IsOfFinOrder (x i)
tactic: obtain ⟨n, npos, hn⟩ := h.exists_pow_eq_one
state_before: case intro.intro
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Monoid G
a b x✝ y : G
n✝ m : ℕ
η : Type u_6
Gs : η → Type u_7
inst✝ : (i : η) → Monoid (Gs i)
x : (i : η) → Gs i
h : IsOfFinOrder x
n : ℕ
npos : 0 < n
hn : x ^ n = 1
⊢ ∀ (i : η), IsOfFinOrder (x i)
state_after: no goals
tactic: exact fun _ => isOfFinOrder_iff_pow_eq_one.mpr ⟨n, npos, (congr_fun hn.symm _).symm⟩
Theorem: geom_gold_isSol_fibRec
File: Mathlib/Data/Real/GoldenRatio.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CommSemiring α
⊢ fibRec.IsSolution fun x => φ ^ x
state_after: α : Type u_1
inst✝ : CommSemiring α
⊢ (X ^ 2 - (X + 1)).IsRoot φ
tactic: rw [fibRec.geom_sol_iff_root_charPoly, fibRec_charPoly_eq]
state_before: α : Type u_1
inst✝ : CommSemiring α
⊢ (X ^ 2 - (X + 1)).IsRoot φ
state_after: no goals
tactic: simp [sub_eq_zero, - div_pow]
Theorem: ZFSet.choice_mem_aux
File: Mathlib/SetTheory/ZFC/Basic.lean

Proof steps:
state_before: x : ZFSet
h : ∅ ∉ x
y : ZFSet
yx : y ∈ x
n : ¬∃ y_1, y_1 ∈ y
⊢ ∅ ∈ x
state_after: no goals
tactic: rwa [← (eq_empty y).2 fun z zx => n ⟨z, zx⟩]
Theorem: ENNReal.div_mul_cancel
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
h0 : a ≠ 0
hI : a ≠ ⊤
⊢ b / a * a = b
state_after: no goals
tactic: rw [div_eq_mul_inv, mul_assoc, ENNReal.inv_mul_cancel h0 hI, mul_one]
Theorem: NumberField.InfinitePlace.card_eq_nrRealPlaces_add_nrComplexPlaces
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

Proof steps:
state_before: k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
⊢ card (InfinitePlace K) = NrRealPlaces K + NrComplexPlaces K
state_after: case h.e'_2
k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
⊢ card (InfinitePlace K) = card { x // x.IsReal ∨ x.IsComplex }
tactic: convert Fintype.card_subtype_or_disjoint (IsReal (K := K)) (IsComplex (K := K))
    (disjoint_isReal_isComplex K) using 1
state_before: case h.e'_2
k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
⊢ card (InfinitePlace K) = card { x // x.IsReal ∨ x.IsComplex }
state_after: no goals
tactic: exact (Fintype.card_of_subtype _ (fun w ↦ ⟨fun _ ↦ isReal_or_isComplex w, fun _ ↦ by simp⟩)).symm
Theorem: MeasureTheory.vadd_set_ae_le
File: Mathlib/MeasureTheory/Group/Action.lean

Proof steps:
state_before: G : Type u
M : Type v
α : Type w
s✝ : Set α
m : MeasurableSpace α
inst✝³ : MeasurableSpace G
inst✝² : Group G
inst✝¹ : MulAction G α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
c : G
s t : Set α
⊢ c • s ≤ᶠ[ae μ] c • t ↔ s ≤ᶠ[ae μ] t
state_after: no goals
tactic: simp only [ae_le_set, ← smul_set_sdiff, measure_smul_eq_zero_iff]
Theorem: Complex.differentiableOn_compl_singleton_and_continuousAt_iff
File: Mathlib/Analysis/Complex/RemovableSingularity.lean

Proof steps:
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
s : Set ℂ
c : ℂ
hs : s ∈ 𝓝 c
⊢ DifferentiableOn ℂ f (s \ {c}) ∧ ContinuousAt f c ↔ DifferentiableOn ℂ f s
state_after: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
s : Set ℂ
c : ℂ
hs : s ∈ 𝓝 c
⊢ DifferentiableOn ℂ f (s \ {c}) ∧ ContinuousAt f c → DifferentiableOn ℂ f s
tactic: refine ⟨?_, fun hd => ⟨hd.mono diff_subset, (hd.differentiableAt hs).continuousAt⟩⟩
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
s : Set ℂ
c : ℂ
hs : s ∈ 𝓝 c
⊢ DifferentiableOn ℂ f (s \ {c}) ∧ ContinuousAt f c → DifferentiableOn ℂ f s
state_after: case intro
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
s : Set ℂ
c : ℂ
hs : s ∈ 𝓝 c
hd : DifferentiableOn ℂ f (s \ {c})
hc : ContinuousAt f c
x : ℂ
hx : x ∈ s
⊢ DifferentiableWithinAt ℂ f s x
tactic: rintro ⟨hd, hc⟩ x hx
state_before: case intro
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
s : Set ℂ
c : ℂ
hs : s ∈ 𝓝 c
hd : DifferentiableOn ℂ f (s \ {c})
hc : ContinuousAt f c
x : ℂ
hx : x ∈ s
⊢ DifferentiableWithinAt ℂ f s x
state_after: case intro.inl
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
s : Set ℂ
x : ℂ
hx : x ∈ s
hs : s ∈ 𝓝 x
hd : DifferentiableOn ℂ f (s \ {x})
hc : ContinuousAt f x
⊢ DifferentiableWithinAt ℂ f s x

case intro.inr
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
s : Set ℂ
c : ℂ
hs : s ∈ 𝓝 c
hd : DifferentiableOn ℂ f (s \ {c})
hc : ContinuousAt f c
x : ℂ
hx : x ∈ s
hne : x ≠ c
⊢ DifferentiableWithinAt ℂ f s x
tactic: rcases eq_or_ne x c with (rfl | hne)
Theorem: Fin.partialProd_succ'
File: Mathlib/Algebra/BigOperators/Fin.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : Monoid α
n : ℕ
f : Fin (n + 1) → α
j : Fin (n + 1)
⊢ partialProd f j.succ = f 0 * partialProd (tail f) j
state_after: α : Type u_1
β : Type u_2
inst✝ : Monoid α
n : ℕ
f : Fin (n + 1) → α
j : Fin (n + 1)
⊢ f 0 * (List.take (↑j) (List.ofFn fun i => f i.succ)).prod = f 0 * (List.take (↑j) (List.ofFn (tail f))).prod
tactic: simp [partialProd]
state_before: α : Type u_1
β : Type u_2
inst✝ : Monoid α
n : ℕ
f : Fin (n + 1) → α
j : Fin (n + 1)
⊢ f 0 * (List.take (↑j) (List.ofFn fun i => f i.succ)).prod = f 0 * (List.take (↑j) (List.ofFn (tail f))).prod
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.CosimplicialObject.Augmented.leftOpRightOpIso_inv_right_app
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : Augmented Cᵒᵖ
⊢ X.leftOp.rightOp.left = X.left
state_after: no goals
tactic: simp
Theorem: Int.abs_sign_of_nonzero
File: Mathlib/Algebra/Order/Group/Int.lean

Proof steps:
state_before: z : ℤ
hz : z ≠ 0
⊢ |z.sign| = 1
state_after: no goals
tactic: rw [abs_eq_natAbs, natAbs_sign_of_nonzero hz, Int.ofNat_one]
Theorem: Cardinal.lift_mk_le_lift_mk_mul_of_lift_mk_preimage_le
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α✝ β✝ α : Type u
β : Type v
c : Cardinal.{max u v}
f : α → β
hf : ∀ (b : β), lift.{v, u} #↑(f ⁻¹' {b}) ≤ c
b : β
⊢ ↑(⇑Equiv.ulift '' ((fun x => { down := f x.down }) ⁻¹' {{ down := b }})) ≃ ↑(f ⁻¹' {b})
state_after: α✝ β✝ α : Type u
β : Type v
c : Cardinal.{max u v}
f : α → β
hf : ∀ (b : β), lift.{v, u} #↑(f ⁻¹' {b}) ≤ c
b : β
⊢ ↑(⇑Equiv.ulift.symm ⁻¹' ((fun x => { down := f x.down }) ⁻¹' {{ down := b }})) ≃ ↑(f ⁻¹' {b})
tactic: rw [Equiv.image_eq_preimage]
state_before: α✝ β✝ α : Type u
β : Type v
c : Cardinal.{max u v}
f : α → β
hf : ∀ (b : β), lift.{v, u} #↑(f ⁻¹' {b}) ≤ c
b : β
⊢ ↑(⇑Equiv.ulift.symm ⁻¹' ((fun x => { down := f x.down }) ⁻¹' {{ down := b }})) ≃ ↑(f ⁻¹' {b})
state_after: α✝ β✝ α : Type u
β : Type v
c : Cardinal.{max u v}
f : α → β
hf : ∀ (b : β), lift.{v, u} #↑(f ⁻¹' {b}) ≤ c
b : β
this : ⇑Equiv.ulift.symm = ULift.up
⊢ ↑(⇑Equiv.ulift.symm ⁻¹' ((fun x => { down := f x.down }) ⁻¹' {{ down := b }})) ≃ ↑(f ⁻¹' {b})
tactic: have : DFunLike.coe (Equiv.symm (Equiv.ulift (α := α))) = ULift.up (α := α) := rfl
state_before: α✝ β✝ α : Type u
β : Type v
c : Cardinal.{max u v}
f : α → β
hf : ∀ (b : β), lift.{v, u} #↑(f ⁻¹' {b}) ≤ c
b : β
this : ⇑Equiv.ulift.symm = ULift.up
⊢ ↑(⇑Equiv.ulift.symm ⁻¹' ((fun x => { down := f x.down }) ⁻¹' {{ down := b }})) ≃ ↑(f ⁻¹' {b})
state_after: α✝ β✝ α : Type u
β : Type v
c : Cardinal.{max u v}
f : α → β
hf : ∀ (b : β), lift.{v, u} #↑(f ⁻¹' {b}) ≤ c
b : β
this : ⇑Equiv.ulift.symm = ULift.up
⊢ ↑(ULift.up ⁻¹' ((fun x => { down := f x.down }) ⁻¹' {{ down := b }})) ≃ ↑(f ⁻¹' {b})
tactic: rw [this]
state_before: α✝ β✝ α : Type u
β : Type v
c : Cardinal.{max u v}
f : α → β
hf : ∀ (b : β), lift.{v, u} #↑(f ⁻¹' {b}) ≤ c
b : β
this : ⇑Equiv.ulift.symm = ULift.up
⊢ ↑(ULift.up ⁻¹' ((fun x => { down := f x.down }) ⁻¹' {{ down := b }})) ≃ ↑(f ⁻¹' {b})
state_after: α✝ β✝ α : Type u
β : Type v
c : Cardinal.{max u v}
f : α → β
hf : ∀ (b : β), lift.{v, u} #↑(f ⁻¹' {b}) ≤ c
b : β
this : ⇑Equiv.ulift.symm = ULift.up
⊢ { x // f x = b } ≃ { x // f x = b }
tactic: simp only [preimage, mem_singleton_iff, ULift.up_inj, mem_setOf_eq, coe_setOf]
state_before: α✝ β✝ α : Type u
β : Type v
c : Cardinal.{max u v}
f : α → β
hf : ∀ (b : β), lift.{v, u} #↑(f ⁻¹' {b}) ≤ c
b : β
this : ⇑Equiv.ulift.symm = ULift.up
⊢ { x // f x = b } ≃ { x // f x = b }
state_after: no goals
tactic: exact Equiv.refl _
Theorem: sbtw_zero_one_iff
File: Mathlib/Analysis/Convex/Between.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x : R
⊢ Sbtw R 0 x 1 ↔ x ∈ Set.Ioo 0 1
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x : R
⊢ (0 ≤ x ∧ x ≤ 1) ∧ x ≠ 0 ∧ x ≠ 1 ↔ 0 < x ∧ x < 1
tactic: rw [Sbtw, wbtw_zero_one_iff, Set.mem_Icc, Set.mem_Ioo]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x : R
⊢ (0 ≤ x ∧ x ≤ 1) ∧ x ≠ 0 ∧ x ≠ 1 ↔ 0 < x ∧ x < 1
state_after: no goals
tactic: exact
    ⟨fun h => ⟨h.1.1.lt_of_ne (Ne.symm h.2.1), h.1.2.lt_of_ne h.2.2⟩, fun h =>
      ⟨⟨h.1.le, h.2.le⟩, h.1.ne', h.2.ne⟩⟩
Theorem: CategoryTheory.IsFiltered.small_fullSubcategory_filteredClosure
File: Mathlib/CategoryTheory/Filtered/Small.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : IsFilteredOrEmpty C
α : Type w
f : α → C
⊢ Small.{max v w, u} (FullSubcategory (FilteredClosure f))
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : IsFilteredOrEmpty C
α : Type w
f : α → C
⊢ ∀ (b : FullSubcategory (FilteredClosure f)),
    ∃ a, CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a = b.obj
tactic: refine small_of_injective_of_exists (FilteredClosureSmall.abstractFilteredClosureRealization f)
    FullSubcategory.ext ?_
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : IsFilteredOrEmpty C
α : Type w
f : α → C
⊢ ∀ (b : FullSubcategory (FilteredClosure f)),
    ∃ a, CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a = b.obj
state_after: case mk
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : IsFilteredOrEmpty C
α : Type w
f : α → C
j : C
h : FilteredClosure f j
⊢ ∃ a,
    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a =
      { obj := j, property := h }.obj
tactic: rintro ⟨j, h⟩
state_before: case mk
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : IsFilteredOrEmpty C
α : Type w
f : α → C
j : C
h : FilteredClosure f j
⊢ ∃ a,
    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a =
      { obj := j, property := h }.obj
state_after: no goals
tactic: induction h with
  | base x => exact ⟨⟨0, ⟨x⟩⟩, rfl⟩
  | max hj₁ hj₂ ih ih' =>
    rcases ih with ⟨⟨n, x⟩, rfl⟩
    rcases ih' with ⟨⟨m, y⟩, rfl⟩
    refine ⟨⟨(Max.max n m).succ, FilteredClosureSmall.InductiveStep.max ?_ ?_ x y⟩, rfl⟩
    all_goals apply Nat.lt_succ_of_le
    exacts [Nat.le_max_left _ _, Nat.le_max_right _ _]
  | coeq hj₁ hj₂ g g' ih ih' =>
    rcases ih with ⟨⟨n, x⟩, rfl⟩
    rcases ih' with ⟨⟨m, y⟩, rfl⟩
    refine ⟨⟨(Max.max n m).succ, FilteredClosureSmall.InductiveStep.coeq ?_ ?_ x y g g'⟩, rfl⟩
    all_goals apply Nat.lt_succ_of_le
    exacts [Nat.le_max_left _ _, Nat.le_max_right _ _]
Theorem: Cardinal.lift_lt_ofENat
File: Mathlib/SetTheory/Cardinal/ENat.lean

Proof steps:
state_before: x : Cardinal.{v}
m : ℕ∞
⊢ lift.{u, v} x < ↑m ↔ x < ↑m
state_after: no goals
tactic: rw [← lift_ofENat.{u, v}, lift_lt]