ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Function.Surjective.denseRange
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f✝¹ : X → Y
s✝ : Set X
x✝ : X
y : Y
α : Type u_4
ι : Type u_5
f✝ : α → X
g : X → Y
f : α → X
s : Set X
hf : Surjective f
x : X
⊢ x ∈ closure (range f)
state_after: no goals
tactic: simp [hf.range_eq]
Theorem: AddSubgroup.intCast_mul_mem_zmultiples
File: Mathlib/Algebra/Group/Subgroup/ZPowers.lean

Proof steps:
state_before: G : Type u_1
inst✝³ : Group G
A : Type u_2
inst✝² : AddGroup A
N : Type u_3
inst✝¹ : Group N
R : Type u_4
inst✝ : Ring R
r : R
k : ℤ
⊢ ↑k * r ∈ zmultiples r
state_after: no goals
tactic: simpa only [← zsmul_eq_mul] using zsmul_mem_zmultiples r k
Theorem: MeasureTheory.measure_preimage_smul_of_nullMeasurableSet
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✝¹ : SMul G α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
s : Set α
hs : NullMeasurableSet s μ
c : G
⊢ μ ((fun x => c • x) ⁻¹' s) = μ s
state_after: G : Type u
M : Type v
α : Type w
s✝ : Set α
m : MeasurableSpace α
inst✝² : MeasurableSpace G
inst✝¹ : SMul G α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
s : Set α
hs : NullMeasurableSet s μ
c : G
⊢ μ ((fun x => c • x) ⁻¹' s) = μ ((fun x => c • x) ⁻¹' toMeasurable μ s)
tactic: rw [← measure_toMeasurable s,
    ← SMulInvariantMeasure.measure_preimage_smul c (measurableSet_toMeasurable μ s)]
state_before: G : Type u
M : Type v
α : Type w
s✝ : Set α
m : MeasurableSpace α
inst✝² : MeasurableSpace G
inst✝¹ : SMul G α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
s : Set α
hs : NullMeasurableSet s μ
c : G
⊢ μ ((fun x => c • x) ⁻¹' s) = μ ((fun x => c • x) ⁻¹' toMeasurable μ s)
state_after: no goals
tactic: exact measure_congr (tendsto_smul_ae μ c hs.toMeasurable_ae_eq) |>.symm
Theorem: AList.insertRec_empty
File: Mathlib/Data/List/AList.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
C : AList β → Sort u_1
H0 : C ∅
IH : (a : α) → (b : β a) → (l : AList β) → a ∉ l → C l → C (insert a b l)
⊢ insertRec H0 IH ∅ = H0
state_after: α : Type u
β : α → Type v
inst✝ : DecidableEq α
C : AList β → Sort u_1
H0 : C ∅
IH : (a : α) → (b : β a) → (l : AList β) → a ∉ l → C l → C (insert a b l)
⊢ insertRec H0 IH { entries := [], nodupKeys := ⋯ } = H0
tactic: change @insertRec α β _ C H0 IH ⟨[], _⟩ = H0
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
C : AList β → Sort u_1
H0 : C ∅
IH : (a : α) → (b : β a) → (l : AList β) → a ∉ l → C l → C (insert a b l)
⊢ insertRec H0 IH { entries := [], nodupKeys := ⋯ } = H0
state_after: no goals
tactic: rw [insertRec]
Theorem: Set.image_fst_graphOn
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✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → β
s : Set α
⊢ Prod.fst '' graphOn f s = s
state_after: no goals
tactic: simp [graphOn, image_image]
Theorem: CategoryTheory.Limits.inr_pushoutAssoc_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/Assoc.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr g₁ g₂) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl g₃ g₄)
⊢ pushout.inr (g₃ ≫ pushout.inr g₁ g₂) g₄ ≫ (pushoutAssoc g₁ g₂ g₃ g₄).hom =
    pushout.inr g₃ g₄ ≫ pushout.inr g₁ (g₂ ≫ pushout.inl g₃ g₄)
state_after: no goals
tactic: rw [← Iso.eq_comp_inv, Category.assoc, inr_inr_pushoutAssoc_inv]
Theorem: SimpleGraph.nonuniformWitness_spec
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean

Proof steps:
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
h₁ : s ≠ t
h₂ : ¬G.IsUniform ε s t
⊢ ε ≤ ↑|G.edgeDensity (G.nonuniformWitness ε s t) (G.nonuniformWitness ε t s) - G.edgeDensity s t|
state_after: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
h₁ : s ≠ t
h₂ : ¬G.IsUniform ε s t
⊢ ε ≤
    ↑|G.edgeDensity (if WellOrderingRel s t then (G.nonuniformWitnesses ε s t).1 else (G.nonuniformWitnesses ε t s).2)
            (if WellOrderingRel t s then (G.nonuniformWitnesses ε t s).1 else (G.nonuniformWitnesses ε s t).2) -
          G.edgeDensity s t|
tactic: unfold nonuniformWitness
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
h₁ : s ≠ t
h₂ : ¬G.IsUniform ε s t
⊢ ε ≤
    ↑|G.edgeDensity (if WellOrderingRel s t then (G.nonuniformWitnesses ε s t).1 else (G.nonuniformWitnesses ε t s).2)
            (if WellOrderingRel t s then (G.nonuniformWitnesses ε t s).1 else (G.nonuniformWitnesses ε s t).2) -
          G.edgeDensity s t|
state_after: case inl
α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
h₁ : s ≠ t
h₂ : ¬G.IsUniform ε s t
lt : WellOrderingRel s t
⊢ ε ≤
    ↑|G.edgeDensity (if WellOrderingRel s t then (G.nonuniformWitnesses ε s t).1 else (G.nonuniformWitnesses ε t s).2)
            (if WellOrderingRel t s then (G.nonuniformWitnesses ε t s).1 else (G.nonuniformWitnesses ε s t).2) -
          G.edgeDensity s t|

case inr.inl
α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s : Finset α
a b : α
h₁ : s ≠ s
h₂ : ¬G.IsUniform ε s s
⊢ ε ≤
    ↑|G.edgeDensity (if WellOrderingRel s s then (G.nonuniformWitnesses ε s s).1 else (G.nonuniformWitnesses ε s s).2)
            (if WellOrderingRel s s then (G.nonuniformWitnesses ε s s).1 else (G.nonuniformWitnesses ε s s).2) -
          G.edgeDensity s s|

case inr.inr
α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
h₁ : s ≠ t
h₂ : ¬G.IsUniform ε s t
gt : WellOrderingRel t s
⊢ ε ≤
    ↑|G.edgeDensity (if WellOrderingRel s t then (G.nonuniformWitnesses ε s t).1 else (G.nonuniformWitnesses ε t s).2)
            (if WellOrderingRel t s then (G.nonuniformWitnesses ε t s).1 else (G.nonuniformWitnesses ε s t).2) -
          G.edgeDensity s t|
tactic: rcases trichotomous_of WellOrderingRel s t with (lt | rfl | gt)
Theorem: Real.rpow_rpow_inv
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : y ≠ 0
⊢ (x ^ y) ^ y⁻¹ = x
state_after: no goals
tactic: rw [← rpow_mul hx, mul_inv_cancel hy, rpow_one]
Theorem: Behrend.exp_neg_two_mul_le
File: Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 0 < x
⊢ rexp (-2 * x) < rexp (2 - ↑⌈x⌉₊) / ↑⌈x⌉₊
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 0 < x
h₁ : ↑⌈x⌉₊ < x + 1
⊢ rexp (-2 * x) < rexp (2 - ↑⌈x⌉₊) / ↑⌈x⌉₊
tactic: have h₁ := ceil_lt_add_one hx.le
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 0 < x
h₁ : ↑⌈x⌉₊ < x + 1
⊢ rexp (-2 * x) < rexp (2 - ↑⌈x⌉₊) / ↑⌈x⌉₊
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 0 < x
h₁ : ↑⌈x⌉₊ < x + 1
h₂ : 1 - x ≤ 2 - ↑⌈x⌉₊
⊢ rexp (-2 * x) < rexp (2 - ↑⌈x⌉₊) / ↑⌈x⌉₊
tactic: have h₂ : 1 - x ≤ 2 - ⌈x⌉₊ := by linarith
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 0 < x
h₁ : ↑⌈x⌉₊ < x + 1
h₂ : 1 - x ≤ 2 - ↑⌈x⌉₊
⊢ rexp (-2 * x) < rexp (2 - ↑⌈x⌉₊) / ↑⌈x⌉₊
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 0 < x
h₁ : ↑⌈x⌉₊ < x + 1
h₂ : 1 - x ≤ 2 - ↑⌈x⌉₊
⊢ rexp (-2 * x) ≤ rexp (1 - x) / (x + 1)
tactic: calc
    _ ≤ exp (1 - x) / (x + 1) := ?_
    _ ≤ exp (2 - ⌈x⌉₊) / (x + 1) := by gcongr
    _ < _ := by gcongr
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 0 < x
h₁ : ↑⌈x⌉₊ < x + 1
h₂ : 1 - x ≤ 2 - ↑⌈x⌉₊
⊢ rexp (-2 * x) ≤ rexp (1 - x) / (x + 1)
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 0 < x
h₁ : ↑⌈x⌉₊ < x + 1
h₂ : 1 - x ≤ 2 - ↑⌈x⌉₊
⊢ x + 1 ≤ rexp (x + 1)
tactic: rw [le_div_iff (add_pos hx zero_lt_one), ← le_div_iff' (exp_pos _), ← exp_sub, neg_mul,
    sub_neg_eq_add, two_mul, sub_add_add_cancel, add_comm _ x]
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 0 < x
h₁ : ↑⌈x⌉₊ < x + 1
h₂ : 1 - x ≤ 2 - ↑⌈x⌉₊
⊢ x + 1 ≤ rexp (x + 1)
state_after: no goals
tactic: exact le_trans (le_add_of_nonneg_right zero_le_one) (add_one_le_exp _)
Theorem: Finset.iInf_finset_image
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : CompleteLattice β
inst✝ : DecidableEq α
f : γ → α
g : α → β
s : Finset γ
⊢ ⨅ x ∈ image f s, g x = ⨅ y ∈ s, g (f y)
state_after: no goals
tactic: rw [← iInf_coe, coe_image, iInf_image, iInf_coe]
Theorem: alternatingGroup.isThreeCycle_isConj
File: Mathlib/GroupTheory/SpecificGroups/Alternating.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
h5 : 5 ≤ card α
σ τ : ↥(alternatingGroup α)
hσ : (↑σ).IsThreeCycle
hτ : (↑τ).IsThreeCycle
⊢ (↑σ).support.card + 2 ≤ card α
state_after: no goals
tactic: rwa [hσ.card_support]
Theorem: MvPolynomial.pderiv_X_self
File: Mathlib/Algebra/MvPolynomial/PDeriv.lean

Proof steps:
state_before: R : Type u
σ : Type v
a a' a₁ a₂ : R
s : σ →₀ ℕ
inst✝ : CommSemiring R
i : σ
⊢ (pderiv i) (X i) = 1
state_after: no goals
tactic: classical simp
Theorem: nsmul_inj_iff_of_addOrderOf_eq_zero
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✝ : LeftCancelMonoid G
x y a : G
m✝ n✝ : ℕ
h : orderOf x = 0
n m : ℕ
⊢ x ^ n = x ^ m ↔ n = m
state_after: no goals
tactic: rw [pow_eq_pow_iff_modEq, h, modEq_zero_iff]
Theorem: CategoryTheory.Square.map_X₂
File: Mathlib/CategoryTheory/Square.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
sq : Square C
F : C ⥤ D
⊢ F.map sq.f₁₂ ≫ F.map sq.f₂₄ = F.map sq.f₁₃ ≫ F.map sq.f₃₄
state_after: no goals
tactic: simpa using F.congr_map sq.fac
Theorem: PiTensorProduct.congr_tprod
File: Mathlib/LinearAlgebra/PiTensorProduct.lean

Proof steps:
state_before: ι : Type u_1
ι₂ : Type u_2
ι₃ : Type u_3
R : Type u_4
inst✝¹¹ : CommSemiring R
R₁ : Type u_5
R₂ : Type u_6
s : ι → Type u_7
inst✝¹⁰ : (i : ι) → AddCommMonoid (s i)
inst✝⁹ : (i : ι) → Module R (s i)
M : Type u_8
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
E : Type u_9
inst✝⁶ : AddCommMonoid E
inst✝⁵ : Module R E
F : Type u_10
inst✝⁴ : AddCommMonoid F
t : ι → Type u_11
t' : ι → Type u_12
inst✝³ : (i : ι) → AddCommMonoid (t i)
inst✝² : (i : ι) → Module R (t i)
inst✝¹ : (i : ι) → AddCommMonoid (t' i)
inst✝ : (i : ι) → Module R (t' i)
g : (i : ι) → t i →ₗ[R] t' i
f✝ : (i : ι) → s i →ₗ[R] t i
f : (i : ι) → s i ≃ₗ[R] t i
m : (i : ι) → s i
⊢ (congr f) ((tprod R) m) = ⨂ₜ[R] (i : ι), (f i) (m i)
state_after: no goals
tactic: simp only [congr, LinearEquiv.ofLinear_apply, map_tprod, LinearEquiv.coe_coe]
Theorem: HilbertBasis.hasSum_orthogonalProjection
File: Mathlib/Analysis/InnerProductSpace/l2Space.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
inst✝⁵ : RCLike 𝕜
E : Type u_3
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝² : (i : ι) → NormedAddCommGroup (G i)
inst✝¹ : (i : ι) → InnerProductSpace 𝕜 (G i)
U : Submodule 𝕜 E
inst✝ : CompleteSpace ↥U
b : HilbertBasis ι 𝕜 ↥U
x : E
⊢ HasSum (fun i => ⟪↑((fun i => b.repr.symm (lp.single 2 i 1)) i), x⟫_𝕜 • (fun i => b.repr.symm (lp.single 2 i 1)) i)
    ((orthogonalProjection U) x)
state_after: no goals
tactic: simpa only [b.repr_apply_apply, inner_orthogonalProjection_eq_of_mem_left] using
    b.hasSum_repr (orthogonalProjection U x)
Theorem: abs_sub_round_eq_min
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
x : α
⊢ |x - ↑(round x)| = min (fract x) (1 - fract x)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
x : α
⊢ |x - ↑(if fract x < 1 - fract x then ⌊x⌋ else ⌈x⌉)| = if fract x < 1 - fract x then fract x else 1 - fract x
tactic: simp_rw [round, min_def_lt, two_mul, ← lt_tsub_iff_left]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
x : α
⊢ |x - ↑(if fract x < 1 - fract x then ⌊x⌋ else ⌈x⌉)| = if fract x < 1 - fract x then fract x else 1 - fract x
state_after: case inl
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
x : α
hx : fract x < 1 - fract x
⊢ |x - ↑(if fract x < 1 - fract x then ⌊x⌋ else ⌈x⌉)| = if fract x < 1 - fract x then fract x else 1 - fract x

case inr
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
x : α
hx : fract x ≥ 1 - fract x
⊢ |x - ↑(if fract x < 1 - fract x then ⌊x⌋ else ⌈x⌉)| = if fract x < 1 - fract x then fract x else 1 - fract x
tactic: cases' lt_or_ge (fract x) (1 - fract x) with hx hx
Theorem: CategoryTheory.shiftFunctorAdd'_zero_add_hom_app
File: Mathlib/CategoryTheory/Shift/Basic.lean

Proof steps:
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a : A
X : C
⊢ (shiftFunctorAdd' C 0 a a ⋯).hom.app X = (shiftFunctor C a).map ((shiftFunctorZero C A).inv.app X)
state_after: no goals
tactic: simpa using NatTrans.congr_app (congr_arg Iso.hom (shiftFunctorAdd'_zero_add C a)) X
Theorem: CategoryTheory.conjugateEquiv_symm_of_iso
File: Mathlib/CategoryTheory/Adjunction/Mates.lean

Proof steps:
state_before: C : Type u₁
D : Type u₂
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Category.{v₂, u₂} D
L₁ L₂ : C ⥤ D
R₁ R₂ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
α : R₁ ⟶ R₂
inst✝ : IsIso ((conjugateEquiv adj₁ adj₂).symm α)
⊢ IsIso α
state_after: C : Type u₁
D : Type u₂
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Category.{v₂, u₂} D
L₁ L₂ : C ⥤ D
R₁ R₂ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
α : R₁ ⟶ R₂
inst✝ : IsIso ((conjugateEquiv adj₁ adj₂).symm α)
⊢ IsIso ((conjugateEquiv adj₁ adj₂) ((conjugateEquiv adj₁ adj₂).symm α))
tactic: suffices IsIso ((conjugateEquiv adj₁ adj₂) ((conjugateEquiv adj₁ adj₂).symm α))
    by simpa using this
state_before: C : Type u₁
D : Type u₂
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Category.{v₂, u₂} D
L₁ L₂ : C ⥤ D
R₁ R₂ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
α : R₁ ⟶ R₂
inst✝ : IsIso ((conjugateEquiv adj₁ adj₂).symm α)
⊢ IsIso ((conjugateEquiv adj₁ adj₂) ((conjugateEquiv adj₁ adj₂).symm α))
state_after: no goals
tactic: infer_instance
Theorem: MeasureTheory.OuterMeasure.comap_iInf
File: Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean

Proof steps:
state_before: α : Type u_1
ι : Sort u_2
β : Type u_3
f : α → β
m : ι → OuterMeasure β
⊢ (comap f) (⨅ i, m i) = ⨅ i, (comap f) (m i)
state_after: α : Type u_1
ι : Sort u_2
β : Type u_3
f : α → β
m : ι → OuterMeasure β
s : Set α
hs : s.Nonempty
⊢ ((comap f) (⨅ i, m i)) s = (⨅ i, (comap f) (m i)) s
tactic: refine ext_nonempty fun s hs => ?_
state_before: α : Type u_1
ι : Sort u_2
β : Type u_3
f : α → β
m : ι → OuterMeasure β
s : Set α
hs : s.Nonempty
⊢ ((comap f) (⨅ i, m i)) s = (⨅ i, (comap f) (m i)) s
state_after: α : Type u_1
ι : Sort u_2
β : Type u_3
f : α → β
m : ι → OuterMeasure β
s : Set α
hs : s.Nonempty
⊢ (⨅ i, (comap f) (m i)) s ≤ ((comap f) (⨅ i, m i)) s
tactic: refine ((comap_mono f).map_iInf_le s).antisymm ?_
state_before: α : Type u_1
ι : Sort u_2
β : Type u_3
f : α → β
m : ι → OuterMeasure β
s : Set α
hs : s.Nonempty
⊢ (⨅ i, (comap f) (m i)) s ≤ ((comap f) (⨅ i, m i)) s
state_after: α : Type u_1
ι : Sort u_2
β : Type u_3
f : α → β
m : ι → OuterMeasure β
s : Set α
hs : s.Nonempty
⊢ ∀ (i : ℕ → Set β),
    s ⊆ ⋃ i_1, f ⁻¹' i i_1 →
      ⨅ t, ⨅ (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨅ i, (m i) (f '' t n) ≤ ∑' (n : ℕ), ⨅ i_2, (m i_2) (i n)
tactic: simp only [comap_apply, iInf_apply' _ hs, iInf_apply' _ (hs.image _), le_iInf_iff,
    Set.image_subset_iff, preimage_iUnion]
state_before: α : Type u_1
ι : Sort u_2
β : Type u_3
f : α → β
m : ι → OuterMeasure β
s : Set α
hs : s.Nonempty
⊢ ∀ (i : ℕ → Set β),
    s ⊆ ⋃ i_1, f ⁻¹' i i_1 →
      ⨅ t, ⨅ (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨅ i, (m i) (f '' t n) ≤ ∑' (n : ℕ), ⨅ i_2, (m i_2) (i n)
state_after: α : Type u_1
ι : Sort u_2
β : Type u_3
f : α → β
m : ι → OuterMeasure β
s : Set α
hs : s.Nonempty
t : ℕ → Set β
ht : s ⊆ ⋃ i, f ⁻¹' t i
k : ℕ
⊢ ⨅ i, (m i) (f '' (f ⁻¹' t k)) ≤ ⨅ i, (m i) (t k)
tactic: refine fun t ht => iInf_le_of_le _ (iInf_le_of_le ht <| ENNReal.tsum_le_tsum fun k => ?_)
state_before: α : Type u_1
ι : Sort u_2
β : Type u_3
f : α → β
m : ι → OuterMeasure β
s : Set α
hs : s.Nonempty
t : ℕ → Set β
ht : s ⊆ ⋃ i, f ⁻¹' t i
k : ℕ
⊢ ⨅ i, (m i) (f '' (f ⁻¹' t k)) ≤ ⨅ i, (m i) (t k)
state_after: no goals
tactic: exact iInf_mono fun i => (m i).mono (image_preimage_subset _ _)
Theorem: CategoryTheory.Over.mapPullbackAdj_counit_app
File: Mathlib/CategoryTheory/Adjunction/Over.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X✝ : C
inst✝ : HasPullbacks C
X Y : C
f : X ⟶ Y
x : Over X
y : Over Y
u : (map f).obj x ⟶ y
⊢ u.left ≫ y.hom = x.hom ≫ f
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X✝ : C
inst✝ : HasPullbacks C
X Y : C
f : X ⟶ Y
x : Over X
y : Over Y
v : x ⟶ (pullback f).obj y
⊢ (v.left ≫ pullback.fst y.hom f) ≫ y.hom = ((map f).obj x).hom
state_after: no goals
tactic: simp [← Over.w v, pullback.condition]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X✝ : C
inst✝ : HasPullbacks C
X Y : C
f : X ⟶ Y
x : Over X
y : Over Y
⊢ Function.LeftInverse (fun v => homMk (v.left ≫ pullback.fst y.hom f) ⋯) fun u =>
    homMk (pullback.lift u.left x.hom ⋯) ⋯
state_after: no goals
tactic: aesop_cat
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X✝ : C
inst✝ : HasPullbacks C
X Y : C
f : X ⟶ Y
x : Over X
y : Over Y
v : x ⟶ (pullback f).obj y
⊢ (fun u => homMk (pullback.lift u.left x.hom ⋯) ⋯) ((fun v => homMk (v.left ≫ pullback.fst y.hom f) ⋯) v) = v
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
X✝ : C
inst✝ : HasPullbacks C
X Y : C
f : X ⟶ Y
x : Over X
y : Over Y
v : x ⟶ (pullback f).obj y
⊢ ((fun u => homMk (pullback.lift u.left x.hom ⋯) ⋯) ((fun v => homMk (v.left ≫ pullback.fst y.hom f) ⋯) v)).left =
    v.left
tactic: ext
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
X✝ : C
inst✝ : HasPullbacks C
X Y : C
f : X ⟶ Y
x : Over X
y : Over Y
v : x ⟶ (pullback f).obj y
⊢ ((fun u => homMk (pullback.lift u.left x.hom ⋯) ⋯) ((fun v => homMk (v.left ≫ pullback.fst y.hom f) ⋯) v)).left =
    v.left
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
X✝ : C
inst✝ : HasPullbacks C
X Y : C
f : X ⟶ Y
x : Over X
y : Over Y
v : x ⟶ (pullback f).obj y
⊢ pullback.lift (v.left ≫ pullback.fst y.hom f) x.hom ⋯ = v.left
tactic: dsimp
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
X✝ : C
inst✝ : HasPullbacks C
X Y : C
f : X ⟶ Y
x : Over X
y : Over Y
v : x ⟶ (pullback f).obj y
⊢ pullback.lift (v.left ≫ pullback.fst y.hom f) x.hom ⋯ = v.left
state_after: case h.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X✝ : C
inst✝ : HasPullbacks C
X Y : C
f : X ⟶ Y
x : Over X
y : Over Y
v : x ⟶ (pullback f).obj y
⊢ pullback.lift (v.left ≫ pullback.fst y.hom f) x.hom ⋯ ≫ pullback.fst y.hom f = v.left ≫ pullback.fst y.hom f

case h.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X✝ : C
inst✝ : HasPullbacks C
X Y : C
f : X ⟶ Y
x : Over X
y : Over Y
v : x ⟶ (pullback f).obj y
⊢ pullback.lift (v.left ≫ pullback.fst y.hom f) x.hom ⋯ ≫ pullback.snd y.hom f = v.left ≫ pullback.snd y.hom f
tactic: ext
Theorem: piiUnionInter_singleton
File: Mathlib/MeasureTheory/PiSystem.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
π : ι → Set (Set α)
i : ι
⊢ piiUnionInter π {i} = π i ∪ {univ}
state_after: case h
α : Type u_1
ι : Type u_2
π : ι → Set (Set α)
i : ι
s : Set α
⊢ s ∈ piiUnionInter π {i} ↔ s ∈ π i ∪ {univ}
tactic: ext1 s
state_before: case h
α : Type u_1
ι : Type u_2
π : ι → Set (Set α)
i : ι
s : Set α
⊢ s ∈ piiUnionInter π {i} ↔ s ∈ π i ∪ {univ}
state_after: case h
α : Type u_1
ι : Type u_2
π : ι → Set (Set α)
i : ι
s : Set α
⊢ s ∈ {s | ∃ t, ↑t ⊆ {i} ∧ ∃ f, (∀ x ∈ t, f x ∈ π x) ∧ s = ⋂ x ∈ t, f x} ↔ s ∈ π i ∨ s ∈ {univ}
tactic: simp only [piiUnionInter, exists_prop, mem_union]
state_before: case h
α : Type u_1
ι : Type u_2
π : ι → Set (Set α)
i : ι
s : Set α
⊢ s ∈ {s | ∃ t, ↑t ⊆ {i} ∧ ∃ f, (∀ x ∈ t, f x ∈ π x) ∧ s = ⋂ x ∈ t, f x} ↔ s ∈ π i ∨ s ∈ {univ}
state_after: case h.refine_1
α : Type u_1
ι : Type u_2
π : ι → Set (Set α)
i : ι
s : Set α
⊢ s ∈ {s | ∃ t, ↑t ⊆ {i} ∧ ∃ f, (∀ x ∈ t, f x ∈ π x) ∧ s = ⋂ x ∈ t, f x} → s ∈ π i ∨ s ∈ {univ}

case h.refine_2
α : Type u_1
ι : Type u_2
π : ι → Set (Set α)
i : ι
s : Set α
h : s ∈ π i ∨ s ∈ {univ}
⊢ s ∈ {s | ∃ t, ↑t ⊆ {i} ∧ ∃ f, (∀ x ∈ t, f x ∈ π x) ∧ s = ⋂ x ∈ t, f x}
tactic: refine ⟨?_, fun h => ?_⟩
Theorem: Real.Angle.nsmul_toReal_eq_mul
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: n : ℕ
h : n ≠ 0
θ : Angle
⊢ (n • θ).toReal = ↑n * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / ↑n) (π / ↑n)
state_after: n : ℕ
h : n ≠ 0
θ : Angle
⊢ (n • ↑θ.toReal).toReal = ↑n * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / ↑n) (π / ↑n)
tactic: nth_rw 1 [← coe_toReal θ]
state_before: n : ℕ
h : n ≠ 0
θ : Angle
⊢ (n • ↑θ.toReal).toReal = ↑n * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / ↑n) (π / ↑n)
state_after: n : ℕ
h : n ≠ 0
θ : Angle
h' : 0 < ↑n
⊢ (n • ↑θ.toReal).toReal = ↑n * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / ↑n) (π / ↑n)
tactic: have h' : 0 < (n : ℝ) := mod_cast Nat.pos_of_ne_zero h
state_before: n : ℕ
h : n ≠ 0
θ : Angle
h' : 0 < ↑n
⊢ (n • ↑θ.toReal).toReal = ↑n * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / ↑n) (π / ↑n)
state_after: no goals
tactic: rw [← coe_nsmul, nsmul_eq_mul, toReal_coe_eq_self_iff, Set.mem_Ioc, div_lt_iff' h',
    le_div_iff' h']
Theorem: AlgebraicGeometry.StructureSheaf.stalkSpecializes_stalk_to_fiber
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

Proof steps:
state_before: R✝ : Type u
inst✝¹ : CommRing R✝
R : Type u_1
inst✝ : CommRing R
x y : PrimeSpectrum R
h : x ⤳ y
⊢ (structureSheaf R).presheaf.stalkSpecializes h ≫ stalkToFiberRingHom R x =
    stalkToFiberRingHom R y ≫
      let_fun this := PrimeSpectrum.localizationMapOfSpecializes h;
      this
state_after: R✝ : Type u
inst✝¹ : CommRing R✝
R : Type u_1
inst✝ : CommRing R
x y : PrimeSpectrum R
h : x ⤳ y
⊢ (structureSheaf R).presheaf.stalkSpecializes h ≫ (stalkIso R x).hom =
    (stalkIso R y).hom ≫
      let_fun this := PrimeSpectrum.localizationMapOfSpecializes h;
      this
tactic: change _ ≫ (StructureSheaf.stalkIso R x).hom = (StructureSheaf.stalkIso R y).hom ≫ _
state_before: R✝ : Type u
inst✝¹ : CommRing R✝
R : Type u_1
inst✝ : CommRing R
x y : PrimeSpectrum R
h : x ⤳ y
⊢ (structureSheaf R).presheaf.stalkSpecializes h ≫ (stalkIso R x).hom =
    (stalkIso R y).hom ≫
      let_fun this := PrimeSpectrum.localizationMapOfSpecializes h;
      this
state_after: R✝ : Type u
inst✝¹ : CommRing R✝
R : Type u_1
inst✝ : CommRing R
x y : PrimeSpectrum R
h : x ⤳ y
⊢ (stalkIso R y).inv ≫ (structureSheaf R).presheaf.stalkSpecializes h =
    (let_fun this := PrimeSpectrum.localizationMapOfSpecializes h;
      this) ≫
      (stalkIso R x).inv
tactic: rw [← Iso.eq_comp_inv, Category.assoc, ← Iso.inv_comp_eq]
state_before: R✝ : Type u
inst✝¹ : CommRing R✝
R : Type u_1
inst✝ : CommRing R
x y : PrimeSpectrum R
h : x ⤳ y
⊢ (stalkIso R y).inv ≫ (structureSheaf R).presheaf.stalkSpecializes h =
    (let_fun this := PrimeSpectrum.localizationMapOfSpecializes h;
      this) ≫
      (stalkIso R x).inv
state_after: no goals
tactic: exact localizationToStalk_stalkSpecializes h
Theorem: zero_sub_add_zero_sub
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ 1 / a * (1 / b) = 1 / (a * b)
state_after: no goals
tactic: simp