ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: pow_le_pow_of_le_one
File: Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
inst✝⁴ : Semiring α
inst✝³ : Preorder α
a b c d : α
inst✝² : ZeroLEOneClass α
inst✝¹ : PosMulMono α
inst✝ : MulPosMono α
ha₀ : 0 ≤ a
ha₁ : a ≤ 1
n✝ m✝ : ℕ
h : n✝.le m✝
⊢ a ^ m✝.succ ≤ a ^ n✝
state_after: α : Type u
β : Type u_1
inst✝⁴ : Semiring α
inst✝³ : Preorder α
a b c d : α
inst✝² : ZeroLEOneClass α
inst✝¹ : PosMulMono α
inst✝ : MulPosMono α
ha₀ : 0 ≤ a
ha₁ : a ≤ 1
n✝ m✝ : ℕ
h : n✝.le m✝
⊢ a * a ^ m✝ ≤ a ^ n✝
tactic: rw [pow_succ']
state_before: α : Type u
β : Type u_1
inst✝⁴ : Semiring α
inst✝³ : Preorder α
a b c d : α
inst✝² : ZeroLEOneClass α
inst✝¹ : PosMulMono α
inst✝ : MulPosMono α
ha₀ : 0 ≤ a
ha₁ : a ≤ 1
n✝ m✝ : ℕ
h : n✝.le m✝
⊢ a * a ^ m✝ ≤ a ^ n✝
state_after: no goals
tactic: exact (mul_le_of_le_one_left (pow_nonneg ha₀ _) ha₁).trans $ pow_le_pow_of_le_one ha₀ ha₁ h
Theorem: Set.infinite_univ_iff
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
⊢ univ.Infinite ↔ Infinite α
state_after: no goals
tactic: rw [Set.Infinite, finite_univ_iff, not_finite_iff_infinite]
Theorem: List.map_dlookup_eq_find
File: Mathlib/Data/List/Sigma.lean

Proof steps:
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b' : β a'
l : List (Sigma β)
⊢ Option.map (Sigma.mk a) (dlookup a (⟨a', b'⟩ :: l)) = find? (fun s => decide (a = s.fst)) (⟨a', b'⟩ :: l)
state_after: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b' : β a'
l : List (Sigma β)
h : a = a'
⊢ Option.map (Sigma.mk a) (dlookup a (⟨a', b'⟩ :: l)) = find? (fun s => decide (a = s.fst)) (⟨a', b'⟩ :: l)

case neg
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b' : β a'
l : List (Sigma β)
h : ¬a = a'
⊢ Option.map (Sigma.mk a) (dlookup a (⟨a', b'⟩ :: l)) = find? (fun s => decide (a = s.fst)) (⟨a', b'⟩ :: l)
tactic: by_cases h : a = a'
Theorem: Polynomial.toFinsupp_eq_one
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a✝ b : R
m n : ℕ
inst✝ : Semiring R
p q a : R[X]
⊢ a.toFinsupp = 1 ↔ a = 1
state_after: no goals
tactic: rw [← toFinsupp_one, toFinsupp_inj]
Theorem: CochainComplex.HomComplex.Cochain.v_comp_XIsoOfEq_hom
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
γ : Cochain F G n
p q q' : ℤ
hpq : p + n = q
hq' : q = q'
⊢ p + n = q'
state_after: no goals
tactic: rw [← hq', hpq]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
γ : Cochain F G n
p q q' : ℤ
hpq : p + n = q
hq' : q = q'
⊢ γ.v p q hpq ≫ (HomologicalComplex.XIsoOfEq G hq').hom = γ.v p q' ⋯
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
γ : Cochain F G n
p q : ℤ
hpq : p + n = q
⊢ γ.v p q hpq ≫ (HomologicalComplex.XIsoOfEq G ⋯).hom = γ.v p q ⋯
tactic: subst hq'
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
γ : Cochain F G n
p q : ℤ
hpq : p + n = q
⊢ γ.v p q hpq ≫ (HomologicalComplex.XIsoOfEq G ⋯).hom = γ.v p q ⋯
state_after: no goals
tactic: simp only [HomologicalComplex.XIsoOfEq, eqToIso_refl, Iso.refl_hom, comp_id]
Theorem: ModP.v_p_lt_val
File: Mathlib/RingTheory/Perfection.lean

Proof steps:
state_before: K : Type u₁
inst✝² : Field K
v : Valuation K ℝ≥0
O : Type u₂
inst✝¹ : CommRing O
inst✝ : Algebra O K
hv : v.Integers O
p : ℕ
hp : Fact (Nat.Prime p)
hvp : Fact (v ↑p ≠ 1)
x : O
⊢ v ↑p < v ((algebraMap O K) x) ↔ (Ideal.Quotient.mk (Ideal.span {↑p})) x ≠ 0
state_after: no goals
tactic: rw [lt_iff_not_le, not_iff_not, ← map_natCast (algebraMap O K) p, hv.le_iff_dvd,
    Ideal.Quotient.eq_zero_iff_mem, Ideal.mem_span_singleton]
Theorem: isTorsionFree_iff_noZeroSMulDivisors_int
File: Mathlib/GroupTheory/Torsion.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
inst✝ : AddGroup G
⊢ AddMonoid.IsTorsionFree G ↔ NoZeroSMulDivisors ℤ G
state_after: G : Type u_1
H : Type u_2
inst✝ : AddGroup G
⊢ (∀ (y : ℤ) (x : G), x ≠ 0 → y ≠ 0 → ¬y • x = 0) ↔ ∀ {c : ℤ} {x : G}, c • x = 0 → c = 0 ∨ x = 0
tactic: simp_rw [AddMonoid.IsTorsionFree, isOfFinAddOrder_iff_zsmul_eq_zero, not_exists, not_and,
    noZeroSMulDivisors_iff, forall_swap (β := ℤ)]
state_before: G : Type u_1
H : Type u_2
inst✝ : AddGroup G
⊢ (∀ (y : ℤ) (x : G), x ≠ 0 → y ≠ 0 → ¬y • x = 0) ↔ ∀ {c : ℤ} {x : G}, c • x = 0 → c = 0 ∨ x = 0
state_after: no goals
tactic: exact forall₂_congr fun _ _ ↦ by tauto
Theorem: Ordinal.toPGame_le
File: Mathlib/SetTheory/Game/Ordinal.lean

Proof steps:
state_before: a b : Ordinal.{u_1}
h : a ≤ b
⊢ a.toPGame ≤ b.toPGame
state_after: a b : Ordinal.{u_1}
h : a ≤ b
i : a.toPGame.LeftMoves
⊢ a.toPGame.moveLeft i ⧏ b.toPGame
tactic: refine le_iff_forall_lf.2 ⟨fun i => ?_, isEmptyElim⟩
state_before: a b : Ordinal.{u_1}
h : a ≤ b
i : a.toPGame.LeftMoves
⊢ a.toPGame.moveLeft i ⧏ b.toPGame
state_after: a b : Ordinal.{u_1}
h : a ≤ b
i : a.toPGame.LeftMoves
⊢ (↑(toLeftMovesToPGame.symm i)).toPGame ⧏ b.toPGame
tactic: rw [toPGame_moveLeft']
state_before: a b : Ordinal.{u_1}
h : a ≤ b
i : a.toPGame.LeftMoves
⊢ (↑(toLeftMovesToPGame.symm i)).toPGame ⧏ b.toPGame
state_after: no goals
tactic: exact toPGame_lf ((toLeftMovesToPGame_symm_lt i).trans_le h)
Theorem: Real.logb_mul_base
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

Proof steps:
state_before: b✝ x y a b : ℝ
h₁ : a ≠ 0
h₂ : b ≠ 0
c : ℝ
⊢ logb (a * b) c = ((logb a c)⁻¹ + (logb b c)⁻¹)⁻¹
state_after: no goals
tactic: rw [← inv_logb_mul_base h₁ h₂ c, inv_inv]
Theorem: MeasureTheory.Measure.pi_ball
File: Mathlib/MeasureTheory/Constructions/Pi.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝³ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
inst✝² : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝¹ : ∀ (i : ι), SigmaFinite (μ i)
inst✝ : (i : ι) → MetricSpace (α i)
x : (i : ι) → α i
r : ℝ
hr : 0 < r
⊢ (Measure.pi μ) (Metric.ball x r) = ∏ i : ι, (μ i) (Metric.ball (x i) r)
state_after: no goals
tactic: rw [ball_pi _ hr, pi_pi]
Theorem: Complex.tendsto_abs_tan_of_cos_eq_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/ComplexDeriv.lean

Proof steps:
state_before: x : ℂ
hx : cos x = 0
⊢ Tendsto (fun x => abs (tan x)) (𝓝[≠] x) atTop
state_after: x : ℂ
hx : cos x = 0
⊢ Tendsto (fun x => ‖sin x‖ / ‖cos x‖) (𝓝[≠] x) atTop
tactic: simp only [tan_eq_sin_div_cos, ← norm_eq_abs, norm_div]
state_before: x : ℂ
hx : cos x = 0
⊢ Tendsto (fun x => ‖sin x‖ / ‖cos x‖) (𝓝[≠] x) atTop
state_after: x : ℂ
hx : cos x = 0
A : sin x ≠ 0
⊢ Tendsto (fun x => ‖sin x‖ / ‖cos x‖) (𝓝[≠] x) atTop
tactic: have A : sin x ≠ 0 := fun h => by simpa [*, sq] using sin_sq_add_cos_sq x
state_before: x : ℂ
hx : cos x = 0
A : sin x ≠ 0
⊢ Tendsto (fun x => ‖sin x‖ / ‖cos x‖) (𝓝[≠] x) atTop
state_after: x : ℂ
hx : cos x = 0
A : sin x ≠ 0
B : Tendsto cos (𝓝[≠] x) (𝓝[≠] 0)
⊢ Tendsto (fun x => ‖sin x‖ / ‖cos x‖) (𝓝[≠] x) atTop
tactic: have B : Tendsto cos (𝓝[≠] x) (𝓝[≠] 0) :=
    hx ▸ (hasDerivAt_cos x).tendsto_punctured_nhds (neg_ne_zero.2 A)
state_before: x : ℂ
hx : cos x = 0
A : sin x ≠ 0
B : Tendsto cos (𝓝[≠] x) (𝓝[≠] 0)
⊢ Tendsto (fun x => ‖sin x‖ / ‖cos x‖) (𝓝[≠] x) atTop
state_after: no goals
tactic: exact continuous_sin.continuousWithinAt.norm.mul_atTop (norm_pos_iff.2 A)
    (tendsto_norm_nhdsWithin_zero.comp B).inv_tendsto_zero
Theorem: MulAction.zpow_add_period_smul
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type v
G : Type u
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u
inst✝¹ : Monoid M
inst✝ : MulAction M α
i : ℤ
g : G
a : α
⊢ g ^ (i + ↑(period g a)) • a = g ^ i • a
state_after: no goals
tactic: rw [← zpow_mod_period_smul, Int.add_emod_self, zpow_mod_period_smul]
Theorem: Dioph.ext
File: Mathlib/NumberTheory/Dioph.lean

Proof steps:
state_before: α β γ : Type u
S S' : Set (α → ℕ)
d : Dioph S
H : ∀ (v : α → ℕ), v ∈ S ↔ v ∈ S'
⊢ Dioph S'
state_after: no goals
tactic: rwa [← Set.ext H]
Theorem: Cardinal.mk_equiv_of_lift_eq
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
⊢ #(α ≃ β') = 2 ^ lift.{v, u} #α
state_after: α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
⊢ ↑2 ^ lift.{v, u} #α = 2 ^ lift.{v, u} #α
tactic: erw [← (lift_mk_eq'.2 ⟨.equivCongr (.refl α) (lift_mk_eq'.1 leq).some⟩).trans (lift_id'.{u,v} _),
    lift_umax.{u,v}, mk_perm_eq_two_power, lift_power, lift_natCast]
state_before: α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
⊢ ↑2 ^ lift.{v, u} #α = 2 ^ lift.{v, u} #α
state_after: no goals
tactic: rfl
Theorem: Multiset.prod_toEnumFinset
File: Mathlib/Data/Multiset/Fintype.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
m✝ : Multiset α
β : Type u_2
inst✝ : CommMonoid β
m : Multiset α
f : α → ℕ → β
⊢ ∏ x ∈ m.toEnumFinset, f x.1 x.2 = ∏ x : m.ToType, f x.fst ↑x.snd
state_after: α : Type u_1
inst✝¹ : DecidableEq α
m✝ : Multiset α
β : Type u_2
inst✝ : CommMonoid β
m : Multiset α
f : α → ℕ → β
⊢ ∏ x ∈ m.toEnumFinset, f x.1 x.2 = ∏ x : { x // x ∈ m.toEnumFinset }, f (↑x).1 (↑x).2

α : Type u_1
inst✝¹ : DecidableEq α
m✝ : Multiset α
β : Type u_2
inst✝ : CommMonoid β
m : Multiset α
f : α → ℕ → β
⊢ ∀ (x : m.ToType), f x.fst ↑x.snd = f (↑(m.coeEquiv x)).1 (↑(m.coeEquiv x)).2
tactic: rw [Fintype.prod_equiv m.coeEquiv (fun x ↦ f x x.2) fun x ↦ f x.1.1 x.1.2]
Theorem: EMetric.diam_triple
File: Mathlib/Topology/EMetricSpace/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
⊢ diam {x, y, z} = max (max (edist x y) (edist x z)) (edist y z)
state_after: no goals
tactic: simp only [diam_insert, iSup_insert, iSup_singleton, diam_singleton, ENNReal.max_zero_right,
    ENNReal.sup_eq_max]
Theorem: MvPolynomial.bind₂_C_left
File: Mathlib/Algebra/MvPolynomial/Monad.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
T : Type u_5
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f : σ → MvPolynomial τ R
⊢ bind₂ C = RingHom.id (MvPolynomial σ R)
state_after: no goals
tactic: ext : 2 <;> simp
Theorem: MvPolynomial.support_rename_of_injective
File: Mathlib/Algebra/MvPolynomial/Rename.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
p : MvPolynomial σ R
f : σ → τ
inst✝ : DecidableEq τ
h : Injective f
⊢ ((rename f) p).support = Finset.image (Finsupp.mapDomain f) p.support
state_after: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
p : MvPolynomial σ R
f : σ → τ
inst✝ : DecidableEq τ
h : Injective f
⊢ support (Finsupp.mapDomain (Finsupp.mapDomain f) p) = Finset.image (Finsupp.mapDomain f) p.support
tactic: rw [rename_eq]
state_before: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
p : MvPolynomial σ R
f : σ → τ
inst✝ : DecidableEq τ
h : Injective f
⊢ support (Finsupp.mapDomain (Finsupp.mapDomain f) p) = Finset.image (Finsupp.mapDomain f) p.support
state_after: no goals
tactic: exact Finsupp.mapDomain_support_of_injective (mapDomain_injective h) _
Theorem: YoungDiagram.rowLen_transpose
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

Proof steps:
state_before: μ : YoungDiagram
i : ℕ
⊢ μ.transpose.rowLen i = μ.colLen i
state_after: no goals
tactic: simp [rowLen, colLen]
Theorem: Tuple.antitone_pair_of_not_sorted'
File: Mathlib/Data/Fin/Tuple/Sort.lean

Proof steps:
state_before: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
σ : Equiv.Perm (Fin n)
h : f ∘ ⇑σ ≠ f ∘ ⇑(sort f)
⊢ ∃ i j, i < j ∧ (f ∘ ⇑σ) j < (f ∘ ⇑σ) i
state_after: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
σ : Equiv.Perm (Fin n)
h : ∀ (i j : Fin n), i < j → (f ∘ ⇑σ) i ≤ (f ∘ ⇑σ) j
⊢ f ∘ ⇑σ = f ∘ ⇑(sort f)
tactic: contrapose! h
state_before: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
σ : Equiv.Perm (Fin n)
h : ∀ (i j : Fin n), i < j → (f ∘ ⇑σ) i ≤ (f ∘ ⇑σ) j
⊢ f ∘ ⇑σ = f ∘ ⇑(sort f)
state_after: no goals
tactic: exact comp_sort_eq_comp_iff_monotone.mpr (monotone_iff_forall_lt.mpr h)
Theorem: CategoryTheory.Iso.comp_inv_eq
File: Mathlib/CategoryTheory/Iso.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
α : X ≅ Y
f : Z ⟶ Y
g : Z ⟶ X
H : f ≫ α.inv = g
⊢ f = g ≫ α.hom
state_after: no goals
tactic: simp [H.symm]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
α : X ≅ Y
f : Z ⟶ Y
g : Z ⟶ X
H : f = g ≫ α.hom
⊢ f ≫ α.inv = g
state_after: no goals
tactic: simp [H]
Theorem: HomologicalComplex.singleObjCyclesSelfIso_inv_naturality
File: Mathlib/Algebra/Homology/SingleHomology.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroObject C
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A B : C
f : A ⟶ B
⊢ (singleObjCyclesSelfIso c j A).inv ≫ cyclesMap ((single C c j).map f) j = f ≫ (singleObjCyclesSelfIso c j B).inv
state_after: no goals
tactic: rw [← cancel_epi (singleObjCyclesSelfIso c j A).hom, Iso.hom_inv_id_assoc,
    ← singleObjCyclesSelfIso_hom_naturality_assoc, Iso.hom_inv_id, comp_id]
Theorem: Nat.swap_mem_divisorsAntidiagonal
File: Mathlib/NumberTheory/Divisors.lean

Proof steps:
state_before: n : ℕ
x : ℕ × ℕ
⊢ x.swap ∈ n.divisorsAntidiagonal ↔ x ∈ n.divisorsAntidiagonal
state_after: no goals
tactic: rw [mem_divisorsAntidiagonal, mem_divisorsAntidiagonal, mul_comm, Prod.swap]
Theorem: SimpleGraph.Subgraph.le_induce_union_right
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : G.Subgraph
s s' : Set V
⊢ G'.induce s' ≤ G'.induce (s ∪ s')
state_after: no goals
tactic: exact (sup_le_iff.mp le_induce_union).2
Theorem: CategoryTheory.Under.w
File: Mathlib/CategoryTheory/Comma/Over.lean

Proof steps:
state_before: T : Type u₁
inst✝ : Category.{v₁, u₁} T
X : T
A B : Under X
f : A ⟶ B
⊢ A.hom ≫ f.right = B.hom
state_after: T : Type u₁
inst✝ : Category.{v₁, u₁} T
X : T
A B : Under X
f : A ⟶ B
this : (Functor.fromPUnit X).map f.left ≫ B.hom = A.hom ≫ (𝟭 T).map f.right
⊢ A.hom ≫ f.right = B.hom
tactic: have := f.w
state_before: T : Type u₁
inst✝ : Category.{v₁, u₁} T
X : T
A B : Under X
f : A ⟶ B
this : (Functor.fromPUnit X).map f.left ≫ B.hom = A.hom ≫ (𝟭 T).map f.right
⊢ A.hom ≫ f.right = B.hom
state_after: no goals
tactic: aesop_cat
Theorem: toIcoMod_add_right_eq_add
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c✝ : α
n : ℤ
a b c : α
⊢ toIcoMod hp a (b + c) = toIcoMod hp (a - c) b + c
state_after: no goals
tactic: simp_rw [toIcoMod, toIcoDiv_sub_eq_toIcoDiv_add', sub_add_eq_add_sub]
Theorem: CategoryTheory.GrothendieckTopology.W_eq_W_range_sheafToPresheaf_obj
File: Mathlib/CategoryTheory/Sites/Localization.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_3, u_1} C
J : GrothendieckTopology C
A : Type u_2
inst✝ : Category.{u_4, u_2} A
⊢ J.W = LeftBousfield.W fun x => x ∈ Set.range (sheafToPresheaf J A).obj
state_after: case h
C : Type u_1
inst✝¹ : Category.{u_3, u_1} C
J : GrothendieckTopology C
A : Type u_2
inst✝ : Category.{u_4, u_2} A
⊢ Presheaf.IsSheaf J = fun x => x ∈ Set.range (sheafToPresheaf J A).obj
tactic: apply congr_arg
state_before: case h
C : Type u_1
inst✝¹ : Category.{u_3, u_1} C
J : GrothendieckTopology C
A : Type u_2
inst✝ : Category.{u_4, u_2} A
⊢ Presheaf.IsSheaf J = fun x => x ∈ Set.range (sheafToPresheaf J A).obj
state_after: case h.h.a
C : Type u_1
inst✝¹ : Category.{u_3, u_1} C
J : GrothendieckTopology C
A : Type u_2
inst✝ : Category.{u_4, u_2} A
P : Cᵒᵖ ⥤ A
⊢ Presheaf.IsSheaf J P ↔ P ∈ Set.range (sheafToPresheaf J A).obj
tactic: ext P
state_before: case h.h.a
C : Type u_1
inst✝¹ : Category.{u_3, u_1} C
J : GrothendieckTopology C
A : Type u_2
inst✝ : Category.{u_4, u_2} A
P : Cᵒᵖ ⥤ A
⊢ Presheaf.IsSheaf J P ↔ P ∈ Set.range (sheafToPresheaf J A).obj
state_after: case h.h.a.mp
C : Type u_1
inst✝¹ : Category.{u_3, u_1} C
J : GrothendieckTopology C
A : Type u_2
inst✝ : Category.{u_4, u_2} A
P : Cᵒᵖ ⥤ A
⊢ Presheaf.IsSheaf J P → P ∈ Set.range (sheafToPresheaf J A).obj

case h.h.a.mpr
C : Type u_1
inst✝¹ : Category.{u_3, u_1} C
J : GrothendieckTopology C
A : Type u_2
inst✝ : Category.{u_4, u_2} A
P : Cᵒᵖ ⥤ A
⊢ P ∈ Set.range (sheafToPresheaf J A).obj → Presheaf.IsSheaf J P
tactic: constructor
Theorem: sub_le_sub_flip
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α✝ : Type u
inst✝⁵ : Group α✝
inst✝⁴ : LinearOrder α✝
inst✝³ : CovariantClass α✝ α✝ (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ c : α✝
α : Type u_1
inst✝² : CommGroup α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ a / b ≤ b / a ↔ a ≤ b
state_after: α✝ : Type u
inst✝⁵ : Group α✝
inst✝⁴ : LinearOrder α✝
inst✝³ : CovariantClass α✝ α✝ (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ c : α✝
α : Type u_1
inst✝² : CommGroup α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ a / b ≤ a⁻¹ * b ↔ a ≤ b
tactic: rw [div_eq_mul_inv b, mul_comm]
state_before: α✝ : Type u
inst✝⁵ : Group α✝
inst✝⁴ : LinearOrder α✝
inst✝³ : CovariantClass α✝ α✝ (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ c : α✝
α : Type u_1
inst✝² : CommGroup α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ a / b ≤ a⁻¹ * b ↔ a ≤ b
state_after: no goals
tactic: exact div_le_inv_mul_iff
Theorem: CategoryTheory.PreGaloisCategory.fiberPullbackEquiv_symm_fst_apply
File: Mathlib/CategoryTheory/Galois/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X A B : C
f : A ⟶ X
g : B ⟶ X
a : ↑(F.obj A)
b : ↑(F.obj B)
h : F.map f a = F.map g b
⊢ F.map (pullback.fst f g) ((fiberPullbackEquiv F f g).symm ⟨(a, b), h⟩) = a
state_after: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X A B : C
f : A ⟶ X
g : B ⟶ X
a : ↑(F.obj A)
b : ↑(F.obj B)
h : F.map f a = F.map g b
⊢ F.map (pullback.fst f g)
      ((PreservesPullback.iso (F ⋙ FintypeCat.incl) f g).inv
        ((Types.pullbackIsoPullback (F.map f) (F.map g)).inv ⟨(a, b), h⟩)) =
    a
tactic: simp [fiberPullbackEquiv]
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X A B : C
f : A ⟶ X
g : B ⟶ X
a : ↑(F.obj A)
b : ↑(F.obj B)
h : F.map f a = F.map g b
⊢ F.map (pullback.fst f g)
      ((PreservesPullback.iso (F ⋙ FintypeCat.incl) f g).inv
        ((Types.pullbackIsoPullback (F.map f) (F.map g)).inv ⟨(a, b), h⟩)) =
    a
state_after: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X A B : C
f : A ⟶ X
g : B ⟶ X
a : ↑(F.obj A)
b : ↑(F.obj B)
h : F.map f a = F.map g b
⊢ ((Types.pullbackIsoPullback (F.map f) (F.map g)).inv ≫
        (PreservesPullback.iso (F ⋙ FintypeCat.incl) f g).inv ≫ (F ⋙ FintypeCat.incl).map (pullback.fst f g))
      ⟨(a, b), h⟩ =
    a
tactic: change ((Types.pullbackIsoPullback _ _).inv ≫ _ ≫
    (F ⋙ FintypeCat.incl).map (pullback.fst f g)) _ = _
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X A B : C
f : A ⟶ X
g : B ⟶ X
a : ↑(F.obj A)
b : ↑(F.obj B)
h : F.map f a = F.map g b
⊢ ((Types.pullbackIsoPullback (F.map f) (F.map g)).inv ≫
        (PreservesPullback.iso (F ⋙ FintypeCat.incl) f g).inv ≫ (F ⋙ FintypeCat.incl).map (pullback.fst f g))
      ⟨(a, b), h⟩ =
    a
state_after: no goals
tactic: erw [PreservesPullback.iso_inv_fst, Types.pullbackIsoPullback_inv_fst]
Theorem: CategoryTheory.Arrow.hom_inv_id_right
File: Mathlib/CategoryTheory/Comma/Arrow.lean

Proof steps:
state_before: T : Type u
inst✝ : Category.{v, u} T
f g : Arrow T
sq : f ⟶ g
e : f ≅ g
⊢ e.hom.right ≫ e.inv.right = 𝟙 f.right
state_after: no goals
tactic: rw [← comp_right, e.hom_inv_id, id_right]
Theorem: SetTheory.PGame.powHalf_le_one
File: Mathlib/SetTheory/Surreal/Dyadic.lean

Proof steps:
state_before: n : ℕ
⊢ powHalf n ≤ 1
state_after: case zero

⊢ powHalf 0 ≤ 1

case succ
n : ℕ
hn : powHalf n ≤ 1
⊢ powHalf (n + 1) ≤ 1
tactic: induction' n with n hn
Theorem: ProbabilityTheory.IsMeasurableRatCDF.stieltjesFunction_le_one
File: Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
x : ℝ
⊢ ↑(hf.stieltjesFunction a) x ≤ 1
state_after: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
x : ℝ
r : ℚ
hrx : x < ↑r
⊢ ↑(hf.stieltjesFunction a) x ≤ 1
tactic: obtain ⟨r, hrx⟩ := exists_rat_gt x
state_before: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
x : ℝ
r : ℚ
hrx : x < ↑r
⊢ ↑(hf.stieltjesFunction a) x ≤ 1
state_after: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
x : ℝ
r : ℚ
hrx : x < ↑r
⊢ ⨅ r, ↑(hf.stieltjesFunction a) ↑↑r ≤ 1
tactic: rw [← StieltjesFunction.iInf_rat_gt_eq]
state_before: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
x : ℝ
r : ℚ
hrx : x < ↑r
⊢ ⨅ r, ↑(hf.stieltjesFunction a) ↑↑r ≤ 1
state_after: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
x : ℝ
r : ℚ
hrx : x < ↑r
⊢ ⨅ r, f a ↑r ≤ 1
tactic: simp_rw [IsMeasurableRatCDF.stieltjesFunction_eq]
state_before: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
x : ℝ
r : ℚ
hrx : x < ↑r
⊢ ⨅ r, f a ↑r ≤ 1
state_after: case intro.refine_1
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
x : ℝ
r : ℚ
hrx : x < ↑r
⊢ BddBelow (range fun r => f a ↑r)

case intro.refine_2
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
x : ℝ
r : ℚ
hrx : x < ↑r
⊢ { r' // x < ↑r' }
tactic: refine ciInf_le_of_le ?_ ?_ (hf.le_one _ _)
Theorem: genericPoint_specializes
File: Mathlib/Topology/Sober.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : QuasiSober α
inst✝ : IrreducibleSpace α
x : α
⊢ x ∈ closure univ
state_after: no goals
tactic: simp
Theorem: lcm_eq_zero_iff
File: Mathlib/Algebra/GCDMonoid/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b : α
h : lcm a b = 0
⊢ a = 0 ∨ b = 0
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b : α
h : lcm a b = 0
this : Associated (a * b) 0
⊢ a = 0 ∨ b = 0
tactic: have : Associated (a * b) 0 := (gcd_mul_lcm a b).symm.trans <| by rw [h, mul_zero]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b : α
h : lcm a b = 0
this : Associated (a * b) 0
⊢ a = 0 ∨ b = 0
state_after: no goals
tactic: rwa [← mul_eq_zero, ← associated_zero_iff_eq_zero]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b : α
⊢ a = 0 ∨ b = 0 → lcm a b = 0
state_after: no goals
tactic: rintro (rfl | rfl) <;> [apply lcm_zero_left; apply lcm_zero_right]