ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Polynomial.cyclotomic_eq_prod_X_pow_sub_one_pow_moebius
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

Proof steps:
state_before: n : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
⊢ (algebraMap R[X] (RatFunc R)) (cyclotomic n R) =
    ∏ i ∈ n.divisorsAntidiagonal, (algebraMap R[X] (RatFunc R)) (X ^ i.2 - 1) ^ μ i.1
state_after: case inl
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
⊢ (algebraMap R[X] (RatFunc R)) (cyclotomic 0 R) =
    ∏ i ∈ Nat.divisorsAntidiagonal 0, (algebraMap R[X] (RatFunc R)) (X ^ i.2 - 1) ^ μ i.1

case inr
n : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
hpos : n > 0
⊢ (algebraMap R[X] (RatFunc R)) (cyclotomic n R) =
    ∏ i ∈ n.divisorsAntidiagonal, (algebraMap R[X] (RatFunc R)) (X ^ i.2 - 1) ^ μ i.1
tactic: rcases n.eq_zero_or_pos with (rfl | hpos)
state_before: case inr
n : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
hpos : n > 0
⊢ (algebraMap R[X] (RatFunc R)) (cyclotomic n R) =
    ∏ i ∈ n.divisorsAntidiagonal, (algebraMap R[X] (RatFunc R)) (X ^ i.2 - 1) ^ μ i.1
state_after: case inr
n : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
hpos : n > 0
h :
  ∀ (n : ℕ),
    0 < n → ∏ i ∈ n.divisors, (algebraMap R[X] (RatFunc R)) (cyclotomic i R) = (algebraMap R[X] (RatFunc R)) (X ^ n - 1)
⊢ (algebraMap R[X] (RatFunc R)) (cyclotomic n R) =
    ∏ i ∈ n.divisorsAntidiagonal, (algebraMap R[X] (RatFunc R)) (X ^ i.2 - 1) ^ μ i.1
tactic: have h : ∀ n : ℕ, 0 < n → (∏ i ∈ Nat.divisors n, algebraMap _ (RatFunc R) (cyclotomic i R)) =
      algebraMap _ _ (X ^ n - 1 : R[X]) := by
    intro n hn
    rw [← prod_cyclotomic_eq_X_pow_sub_one hn R, map_prod]
state_before: case inr
n : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
hpos : n > 0
h :
  ∀ (n : ℕ),
    0 < n → ∏ i ∈ n.divisors, (algebraMap R[X] (RatFunc R)) (cyclotomic i R) = (algebraMap R[X] (RatFunc R)) (X ^ n - 1)
⊢ (algebraMap R[X] (RatFunc R)) (cyclotomic n R) =
    ∏ i ∈ n.divisorsAntidiagonal, (algebraMap R[X] (RatFunc R)) (X ^ i.2 - 1) ^ μ i.1
state_after: n : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
hpos : n > 0
h :
  ∀ (n : ℕ),
    0 < n → ∏ i ∈ n.divisors, (algebraMap R[X] (RatFunc R)) (cyclotomic i R) = (algebraMap R[X] (RatFunc R)) (X ^ n - 1)
⊢ ∀ (n : ℕ), 0 < n → ¬cyclotomic n R = 0

n : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
hpos : n > 0
h :
  ∀ (n : ℕ),
    0 < n → ∏ i ∈ n.divisors, (algebraMap R[X] (RatFunc R)) (cyclotomic i R) = (algebraMap R[X] (RatFunc R)) (X ^ n - 1)
⊢ ∀ (n : ℕ), 0 < n → ¬X ^ n - 1 = 0
tactic: rw [(prod_eq_iff_prod_pow_moebius_eq_of_nonzero (fun n hn => _) fun n hn => _).1 h n hpos] <;>
    simp_rw [Ne, IsFractionRing.to_map_eq_zero_iff]
Theorem: MeasureTheory.Measure.haar.add_prehaar_le_addIndex
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K : Compacts G
hU : (interior U).Nonempty
⊢ prehaar (↑K₀) U K ≤ ↑(index ↑K ↑K₀)
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K : Compacts G
hU : (interior U).Nonempty
⊢ ↑(index (↑K) U) / ↑(index (↑K₀) U) ≤ ↑(index ↑K ↑K₀)
tactic: unfold prehaar
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K : Compacts G
hU : (interior U).Nonempty
⊢ ↑(index (↑K) U) / ↑(index (↑K₀) U) ≤ ↑(index ↑K ↑K₀)
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K : Compacts G
hU : (interior U).Nonempty
⊢ index (↑K) U ≤ index ↑K ↑K₀ * index (↑K₀) U

G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K : Compacts G
hU : (interior U).Nonempty
⊢ 0 < index (↑K₀) U
tactic: rw [div_le_iff] <;> norm_cast
Theorem: isPreconnected_of_forall_pair
File: Mathlib/Topology/Connected/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s✝ t u v s : Set α
H : ∀ x ∈ s, ∀ y ∈ s, ∃ t ⊆ s, x ∈ t ∧ y ∈ t ∧ IsPreconnected t
⊢ IsPreconnected s
state_after: case inl
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v : Set α
H : ∀ x ∈ ∅, ∀ y ∈ ∅, ∃ t ⊆ ∅, x ∈ t ∧ y ∈ t ∧ IsPreconnected t
⊢ IsPreconnected ∅

case inr.intro
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s✝ t u v s : Set α
H : ∀ x ∈ s, ∀ y ∈ s, ∃ t ⊆ s, x ∈ t ∧ y ∈ t ∧ IsPreconnected t
x : α
hx : x ∈ s
⊢ IsPreconnected s
tactic: rcases eq_empty_or_nonempty s with (rfl | ⟨x, hx⟩)
state_before: case inl
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v : Set α
H : ∀ x ∈ ∅, ∀ y ∈ ∅, ∃ t ⊆ ∅, x ∈ t ∧ y ∈ t ∧ IsPreconnected t
⊢ IsPreconnected ∅

case inr.intro
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s✝ t u v s : Set α
H : ∀ x ∈ s, ∀ y ∈ s, ∃ t ⊆ s, x ∈ t ∧ y ∈ t ∧ IsPreconnected t
x : α
hx : x ∈ s
⊢ IsPreconnected s
state_after: no goals
tactic: exacts [isPreconnected_empty, isPreconnected_of_forall x fun y => H x hx y]
Theorem: Mathlib.Tactic.Ring.pow_bit0
File: Mathlib/Tactic/Ring/Basic.lean

Proof steps:
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R : Type u_1
inst✝ : CommSemiring R
a a' a₁ a₂ a₃ b b' b₁ b₂ b₃ c c₁ c₂ : R
k : ℕ
x✝¹ : a ^ k = b
x✝ : b * b = c
⊢ a ^ Nat.mul 2 k = c
state_after: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R : Type u_1
inst✝ : CommSemiring R
a a' a₁ a₂ a₃ b' b₁ b₂ b₃ c₁ c₂ : R
k : ℕ
⊢ a ^ Nat.mul 2 k = a ^ k * a ^ k
tactic: subst_vars
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R : Type u_1
inst✝ : CommSemiring R
a a' a₁ a₂ a₃ b' b₁ b₂ b₃ c₁ c₂ : R
k : ℕ
⊢ a ^ Nat.mul 2 k = a ^ k * a ^ k
state_after: no goals
tactic: simp [Nat.succ_mul, pow_add]
Theorem: Sym.card_sym_eq_choose
File: Mathlib/Data/Sym/Card.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
n : ℕ
α : Type u_3
inst✝¹ : Fintype α
k : ℕ
inst✝ : Fintype (Sym α k)
⊢ Fintype.card (Sym α k) = (Fintype.card α + k - 1).choose k
state_after: no goals
tactic: rw [card_sym_eq_multichoose, Nat.multichoose_eq]
Theorem: Complex.arg_eq_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x z✝ z : ℂ
⊢ z.arg = 0 ↔ 0 ≤ z.re ∧ z.im = 0
state_after: case refine_1
a x z✝ z : ℂ
h : z.arg = 0
⊢ 0 ≤ z.re ∧ z.im = 0

case refine_2
a x z✝ z : ℂ
⊢ 0 ≤ z.re ∧ z.im = 0 → z.arg = 0
tactic: refine ⟨fun h => ?_, ?_⟩
Theorem: Filter.tendsto_comp_val_Ici_atTop
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : SemilatticeSup α
a : α
f : α → β
l : Filter β
⊢ Tendsto (fun x => f ↑x) atTop l ↔ Tendsto f atTop l
state_after: no goals
tactic: rw [← map_val_Ici_atTop a, tendsto_map'_iff, Function.comp_def]
Theorem: ProbabilityTheory.Kernel.measurable_lintegral_indicator_const
File: Mathlib/Probability/Kernel/MeasurableIntegral.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
a : α
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
t : Set (α × β)
ht : MeasurableSet t
c : ℝ≥0∞
⊢ Measurable fun a => ∫⁻ (b : β), t.indicator (Function.const (α × β) c) (a, b) ∂κ a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
a : α
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
t : Set (α × β)
ht : MeasurableSet t
c : ℝ≥0∞
⊢ Measurable fun x => c * (κ x) (Prod.mk x ⁻¹' t)
tactic: conv =>
    congr
    ext
    erw [lintegral_indicator_const_comp measurable_prod_mk_left ht _]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
a : α
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
t : Set (α × β)
ht : MeasurableSet t
c : ℝ≥0∞
⊢ Measurable fun x => c * (κ x) (Prod.mk x ⁻¹' t)
state_after: no goals
tactic: exact Measurable.const_mul (measurable_kernel_prod_mk_left ht) c
Theorem: Finset.centerMass_mem_convexHull_of_nonpos
File: Mathlib/Analysis/Convex/Combination.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
E : Type u_3
F : Type u_4
ι : Type u_5
ι' : Type u_6
α : Type u_7
inst✝⁸ : LinearOrderedField R
inst✝⁷ : LinearOrderedField R'
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s : Set E
i j : ι
c : R
t✝ : Finset ι
w : ι → R
z : ι → E
t : Finset ι
hw₀ : ∀ i ∈ t, w i ≤ 0
hws : ∑ i ∈ t, w i < 0
hz : ∀ i ∈ t, z i ∈ s
⊢ t.centerMass w z ∈ (convexHull R) s
state_after: R : Type u_1
R' : Type u_2
E : Type u_3
F : Type u_4
ι : Type u_5
ι' : Type u_6
α : Type u_7
inst✝⁸ : LinearOrderedField R
inst✝⁷ : LinearOrderedField R'
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s : Set E
i j : ι
c : R
t✝ : Finset ι
w : ι → R
z : ι → E
t : Finset ι
hw₀ : ∀ i ∈ t, w i ≤ 0
hws : ∑ i ∈ t, w i < 0
hz : ∀ i ∈ t, z i ∈ s
⊢ t.centerMass (-w) z ∈ (convexHull R) s
tactic: rw [← centerMass_neg_left]
state_before: R : Type u_1
R' : Type u_2
E : Type u_3
F : Type u_4
ι : Type u_5
ι' : Type u_6
α : Type u_7
inst✝⁸ : LinearOrderedField R
inst✝⁷ : LinearOrderedField R'
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s : Set E
i j : ι
c : R
t✝ : Finset ι
w : ι → R
z : ι → E
t : Finset ι
hw₀ : ∀ i ∈ t, w i ≤ 0
hws : ∑ i ∈ t, w i < 0
hz : ∀ i ∈ t, z i ∈ s
⊢ t.centerMass (-w) z ∈ (convexHull R) s
state_after: no goals
tactic: exact Finset.centerMass_mem_convexHull _ (fun _i hi ↦ neg_nonneg.2 <| hw₀ _ hi) (by simpa) hz
Theorem: CategoryTheory.IsHomLift.eqToHom_comp_lift_iff
File: Mathlib/CategoryTheory/FiberedCategory/HomLift.lean

Proof steps:
state_before: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p : 𝒳 ⥤ 𝒮
R S : 𝒮
a b b' : 𝒳
f : R ⟶ S
φ : a ⟶ b
h : b = b'
hφ' : p.IsHomLift f (φ ≫ eqToHom h)
⊢ p.IsHomLift f φ
state_after: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p : 𝒳 ⥤ 𝒮
R S : 𝒮
a b : 𝒳
f : R ⟶ S
φ : a ⟶ b
hφ' : p.IsHomLift f (φ ≫ eqToHom ⋯)
⊢ p.IsHomLift f φ
tactic: subst h
state_before: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p : 𝒳 ⥤ 𝒮
R S : 𝒮
a b : 𝒳
f : R ⟶ S
φ : a ⟶ b
hφ' : p.IsHomLift f (φ ≫ eqToHom ⋯)
⊢ p.IsHomLift f φ
state_after: no goals
tactic: simpa using hφ'
Theorem: PythagoreanTriple.mul_isClassified
File: Mathlib/NumberTheory/PythagoreanTriples.lean

Proof steps:
state_before: x y z : ℤ
h : PythagoreanTriple x y z
k : ℤ
hc : h.IsClassified
⊢ ⋯.IsClassified
state_after: case intro.intro.intro.intro.inl.intro
z k l m n : ℤ
co : m.gcd n = 1
h : PythagoreanTriple (l * (m ^ 2 - n ^ 2)) (l * (2 * m * n)) z
⊢ ⋯.IsClassified

case intro.intro.intro.intro.inr.intro
z k l m n : ℤ
co : m.gcd n = 1
h : PythagoreanTriple (l * (2 * m * n)) (l * (m ^ 2 - n ^ 2)) z
⊢ ⋯.IsClassified
tactic: obtain ⟨l, m, n, ⟨⟨rfl, rfl⟩ | ⟨rfl, rfl⟩, co⟩⟩ := hc
Theorem: Filter.le_countableGenerate_iff_of_countableInterFilter
File: Mathlib/Order/Filter/CountableInter.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝¹ : CountableInterFilter l
g : Set (Set α)
f : Filter α
inst✝ : CountableInterFilter f
⊢ f ≤ countableGenerate g ↔ g ⊆ f.sets
state_after: case mp
ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝¹ : CountableInterFilter l
g : Set (Set α)
f : Filter α
inst✝ : CountableInterFilter f
h : f ≤ countableGenerate g
⊢ g ⊆ f.sets

case mpr
ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝¹ : CountableInterFilter l
g : Set (Set α)
f : Filter α
inst✝ : CountableInterFilter f
h : g ⊆ f.sets
⊢ f ≤ countableGenerate g
tactic: constructor <;> intro h
state_before: case mpr
ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝¹ : CountableInterFilter l
g : Set (Set α)
f : Filter α
inst✝ : CountableInterFilter f
h : g ⊆ f.sets
⊢ f ≤ countableGenerate g
state_after: case mpr
ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝¹ : CountableInterFilter l
g : Set (Set α)
f : Filter α
inst✝ : CountableInterFilter f
h : g ⊆ f.sets
s : Set α
hs : s ∈ countableGenerate g
⊢ s ∈ f
tactic: intro s hs
state_before: case mpr
ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝¹ : CountableInterFilter l
g : Set (Set α)
f : Filter α
inst✝ : CountableInterFilter f
h : g ⊆ f.sets
s : Set α
hs : s ∈ countableGenerate g
⊢ s ∈ f
state_after: case mpr.basic
ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝¹ : CountableInterFilter l
g : Set (Set α)
f : Filter α
inst✝ : CountableInterFilter f
h : g ⊆ f.sets
s✝ s : Set α
hs : s ∈ g
⊢ s ∈ f

case mpr.univ
ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝¹ : CountableInterFilter l
g : Set (Set α)
f : Filter α
inst✝ : CountableInterFilter f
h : g ⊆ f.sets
s : Set α
⊢ univ ∈ f

case mpr.superset
ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝¹ : CountableInterFilter l
g : Set (Set α)
f : Filter α
inst✝ : CountableInterFilter f
h : g ⊆ f.sets
s✝ s t : Set α
a✝ : CountableGenerateSets g s
st : s ⊆ t
ih : s ∈ f
⊢ t ∈ f

case mpr.sInter
ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝¹ : CountableInterFilter l
g : Set (Set α)
f : Filter α
inst✝ : CountableInterFilter f
h : g ⊆ f.sets
s : Set α
S : Set (Set α)
Sct : S.Countable
a✝ : ∀ s ∈ S, CountableGenerateSets g s
ih : ∀ s ∈ S, s ∈ f
⊢ ⋂₀ S ∈ f
tactic: induction' hs with s hs s t _ st ih S Sct _ ih
state_before: case mpr.sInter
ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝¹ : CountableInterFilter l
g : Set (Set α)
f : Filter α
inst✝ : CountableInterFilter f
h : g ⊆ f.sets
s : Set α
S : Set (Set α)
Sct : S.Countable
a✝ : ∀ s ∈ S, CountableGenerateSets g s
ih : ∀ s ∈ S, s ∈ f
⊢ ⋂₀ S ∈ f
state_after: no goals
tactic: exact (countable_sInter_mem Sct).mpr ih
Theorem: Finmap.keys_erase_toFinset
File: Mathlib/Data/Finmap.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
s : AList β
⊢ ⟦AList.erase a s⟧.keys = ⟦s⟧.keys.erase a
state_after: no goals
tactic: simp [Finset.erase, keys, AList.erase, keys_kerase]
Theorem: HomologicalComplex₂.ιTotalOrZero_map
File: Mathlib/Algebra/Homology/TotalComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝⁵ : Category.{u_5, u_1} C
inst✝⁴ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝³ : DecidableEq I₁₂
inst✝² : TotalComplexShape c₁ c₂ c₁₂
inst✝¹ : K.HasTotal c₁₂
inst✝ : L.HasTotal c₁₂
i₁ : I₁
i₂ : I₂
i₁₂ : I₁₂
⊢ K.ιTotalOrZero c₁₂ i₁ i₂ i₁₂ ≫ (total.map φ c₁₂).f i₁₂ = (φ.f i₁).f i₂ ≫ L.ιTotalOrZero c₁₂ i₁ i₂ i₁₂
state_after: no goals
tactic: simp [total.map, ιTotalOrZero]
Theorem: CategoryTheory.Adjunction.toMonad_η
File: Mathlib/CategoryTheory/Monad/Adjunction.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X : C
⊢ (L ⋙ R).map ((whiskerRight (whiskerLeft L h.counit) R).app X) ≫ (whiskerRight (whiskerLeft L h.counit) R).app X =
    (whiskerRight (whiskerLeft L h.counit) R).app ((L ⋙ R).obj X) ≫ (whiskerRight (whiskerLeft L h.counit) R).app X
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X : C
⊢ R.map (L.map (R.map (h.counit.app (L.obj X)))) ≫ R.map (h.counit.app (L.obj X)) =
    R.map (h.counit.app (L.obj (R.obj (L.obj X)))) ≫ R.map (h.counit.app (L.obj X))
tactic: dsimp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X : C
⊢ R.map (L.map (R.map (h.counit.app (L.obj X)))) ≫ R.map (h.counit.app (L.obj X)) =
    R.map (h.counit.app (L.obj (R.obj (L.obj X)))) ≫ R.map (h.counit.app (L.obj X))
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X : C
⊢ R.map (L.map (R.map (h.counit.app (L.obj X))) ≫ h.counit.app (L.obj X)) =
    R.map (h.counit.app (L.obj (R.obj (L.obj X)))) ≫ R.map (h.counit.app (L.obj X))
tactic: rw [← R.map_comp]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X : C
⊢ R.map (L.map (R.map (h.counit.app (L.obj X))) ≫ h.counit.app (L.obj X)) =
    R.map (h.counit.app (L.obj (R.obj (L.obj X)))) ≫ R.map (h.counit.app (L.obj X))
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X : C
⊢ (L ⋙ R).map (h.unit.app X) ≫ (whiskerRight (whiskerLeft L h.counit) R).app X = 𝟙 ((L ⋙ R).obj ((𝟭 C).obj X))
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X : C
⊢ R.map (L.map (h.unit.app X)) ≫ R.map (h.counit.app (L.obj X)) = 𝟙 (R.obj (L.obj X))
tactic: dsimp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X : C
⊢ R.map (L.map (h.unit.app X)) ≫ R.map (h.counit.app (L.obj X)) = 𝟙 (R.obj (L.obj X))
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X : C
⊢ R.map (L.map (h.unit.app X) ≫ h.counit.app (L.obj X)) = 𝟙 (R.obj (L.obj X))
tactic: rw [← R.map_comp]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X : C
⊢ R.map (L.map (h.unit.app X) ≫ h.counit.app (L.obj X)) = 𝟙 (R.obj (L.obj X))
state_after: no goals
tactic: simp
Theorem: Nat.prod_pow_factorization_centralBinom
File: Mathlib/Data/Nat/Choose/Factorization.lean

Proof steps:
state_before: p n✝ k n : ℕ
⊢ ∏ p ∈ Finset.range (2 * n + 1), p ^ n.centralBinom.factorization p = n.centralBinom
state_after: case hkn
p n✝ k n : ℕ
⊢ n ≤ 2 * n
tactic: apply prod_pow_factorization_choose
state_before: case hkn
p n✝ k n : ℕ
⊢ n ≤ 2 * n
state_after: no goals
tactic: omega
Theorem: Irrational.beattySeq'_pos_eq
File: Mathlib/NumberTheory/Rayleigh.lean

Proof steps:
state_before: r : ℝ
hr : Irrational r
⊢ {x | ∃ k > 0, beattySeq' r k = x} = {x | ∃ k > 0, beattySeq r k = x}
state_after: r : ℝ
hr : Irrational r
⊢ {x | ∃ k > 0, ⌈↑k * r⌉ - 1 = x} = {x | ∃ k > 0, ⌊↑k * r⌋ = x}
tactic: dsimp only [beattySeq, beattySeq']
state_before: r : ℝ
hr : Irrational r
⊢ {x | ∃ k > 0, ⌈↑k * r⌉ - 1 = x} = {x | ∃ k > 0, ⌊↑k * r⌋ = x}
state_after: case h.e'_2.h.h.e'_2.h.a
r : ℝ
hr : Irrational r
x✝¹ x✝ : ℤ
⊢ x✝ > 0 ∧ ⌈↑x✝ * r⌉ - 1 = x✝¹ ↔ x✝ > 0 ∧ ⌊↑x✝ * r⌋ = x✝¹
tactic: congr! 4
state_before: case h.e'_2.h.h.e'_2.h.a
r : ℝ
hr : Irrational r
x✝¹ x✝ : ℤ
⊢ x✝ > 0 ∧ ⌈↑x✝ * r⌉ - 1 = x✝¹ ↔ x✝ > 0 ∧ ⌊↑x✝ * r⌋ = x✝¹
state_after: case h.e'_2.h.h.e'_2.h.a
r : ℝ
hr : Irrational r
x✝ k : ℤ
⊢ k > 0 ∧ ⌈↑k * r⌉ - 1 = x✝ ↔ k > 0 ∧ ⌊↑k * r⌋ = x✝
tactic: rename_i k
state_before: case h.e'_2.h.h.e'_2.h.a
r : ℝ
hr : Irrational r
x✝ k : ℤ
⊢ k > 0 ∧ ⌈↑k * r⌉ - 1 = x✝ ↔ k > 0 ∧ ⌊↑k * r⌋ = x✝
state_after: case h.e'_2.h.h.e'_2.h.a
r : ℝ
hr : Irrational r
x✝ k : ℤ
⊢ k > 0 → (⌈↑k * r⌉ - 1 = x✝ ↔ ⌊↑k * r⌋ = x✝)
tactic: rw [and_congr_right_iff]
state_before: case h.e'_2.h.h.e'_2.h.a
r : ℝ
hr : Irrational r
x✝ k : ℤ
⊢ k > 0 → (⌈↑k * r⌉ - 1 = x✝ ↔ ⌊↑k * r⌋ = x✝)
state_after: case h.e'_2.h.h.e'_2.h.a
r : ℝ
hr : Irrational r
x✝ k : ℤ
hk : k > 0
⊢ ⌈↑k * r⌉ - 1 = x✝ ↔ ⌊↑k * r⌋ = x✝
tactic: intro hk
state_before: case h.e'_2.h.h.e'_2.h.a
r : ℝ
hr : Irrational r
x✝ k : ℤ
hk : k > 0
⊢ ⌈↑k * r⌉ - 1 = x✝ ↔ ⌊↑k * r⌋ = x✝
state_after: case h.e'_2.h.h.e'_2.h.a.a.h.e'_2
r : ℝ
hr : Irrational r
x✝ k : ℤ
hk : k > 0
⊢ ⌈↑k * r⌉ - 1 = ⌊↑k * r⌋
tactic: congr!
state_before: case h.e'_2.h.h.e'_2.h.a.a.h.e'_2
r : ℝ
hr : Irrational r
x✝ k : ℤ
hk : k > 0
⊢ ⌈↑k * r⌉ - 1 = ⌊↑k * r⌋
state_after: case h.e'_2.h.h.e'_2.h.a.a.h.e'_2
r : ℝ
hr : Irrational r
x✝ k : ℤ
hk : k > 0
⊢ ↑⌊↑k * r⌋ < ↑k * r ∧ ↑k * r ≤ ↑⌊↑k * r⌋ + 1
tactic: rw [sub_eq_iff_eq_add, Int.ceil_eq_iff, Int.cast_add, Int.cast_one, add_sub_cancel_right]
state_before: case h.e'_2.h.h.e'_2.h.a.a.h.e'_2
r : ℝ
hr : Irrational r
x✝ k : ℤ
hk : k > 0
⊢ ↑⌊↑k * r⌋ < ↑k * r ∧ ↑k * r ≤ ↑⌊↑k * r⌋ + 1
state_after: case h.e'_2.h.h.e'_2.h.a.a.h.e'_2
r : ℝ
hr : Irrational r
x✝ k : ℤ
hk : k > 0
h : ↑⌊↑k * r⌋ = ↑k * r
⊢ False
tactic: refine ⟨(Int.floor_le _).lt_of_ne fun h ↦ ?_, (Int.lt_floor_add_one _).le⟩
state_before: case h.e'_2.h.h.e'_2.h.a.a.h.e'_2
r : ℝ
hr : Irrational r
x✝ k : ℤ
hk : k > 0
h : ↑⌊↑k * r⌋ = ↑k * r
⊢ False
state_after: no goals
tactic: exact (hr.int_mul hk.ne').ne_int ⌊k * r⌋ h.symm
Theorem: Finset.mem_subtype
File: Mathlib/Data/Finset/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : α → Prop
inst✝ : DecidablePred p
s : Finset α
a : α
ha : p a
⊢ ⟨a, ha⟩ ∈ Finset.subtype p s ↔ ↑⟨a, ha⟩ ∈ s
state_after: no goals
tactic: simp [Finset.subtype, ha]
Theorem: Pretrivialization.linearMapAt_apply
File: Mathlib/Topology/VectorBundle/Basic.lean

Proof steps:
state_before: R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁷ : Semiring R
inst✝⁶ : TopologicalSpace F
inst✝⁵ : TopologicalSpace B
e✝ : Pretrivialization F TotalSpace.proj
x : TotalSpace F E
b✝ : B
y✝ : E b✝
inst✝⁴ : AddCommMonoid F
inst✝³ : Module R F
inst✝² : (x : B) → AddCommMonoid (E x)
inst✝¹ : (x : B) → Module R (E x)
e : Pretrivialization F TotalSpace.proj
inst✝ : Pretrivialization.IsLinear R e
b : B
y : E b
⊢ (Pretrivialization.linearMapAt R e b) y = if b ∈ e.baseSet then (↑e { proj := b, snd := y }).2 else 0
state_after: no goals
tactic: rw [coe_linearMapAt]
Theorem: LinearMap.injective_restrict_iff_disjoint
File: Mathlib/Algebra/Module/Submodule/Ker.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
K : Type u_5
M : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₃ : Type u_9
V : Type u_10
V₂ : Type u_11
inst✝¹¹ : Ring R
inst✝¹⁰ : Ring R₂
inst✝⁹ : Ring R₃
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : Module R M
inst✝⁴ : Module R₂ M₂
inst✝³ : Module R₃ M₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝² : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_12
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F τ₁₂ M M₂
f✝ : F
p : Submodule R M
f : M →ₗ[R] M
hf : ∀ x ∈ p, f x ∈ p
⊢ Injective ⇑(f.restrict hf) ↔ Disjoint p (ker f)
state_after: no goals
tactic: rw [← ker_eq_bot, ker_restrict hf, ker_eq_bot, injective_domRestrict_iff, disjoint_iff]