ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Mathlib.Meta.Positivity.nz_of_isRat
File: Mathlib/Tactic/Positivity/Core.lean

Proof steps:
state_before: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℤ
d : ℕ
inst✝ : LinearOrderedRing A
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h : decide (n < 0) = true
⊢ e ≠ 0
state_after: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℤ
d : ℕ
inst✝ : LinearOrderedRing A
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h : decide (n < 0) = true
pos_invOf_d : 0 < ⅟↑d
⊢ e ≠ 0
tactic: have pos_invOf_d : (0 < ⅟ (d : A)) := pos_invOf_of_invertible_cast d
state_before: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℤ
d : ℕ
inst✝ : LinearOrderedRing A
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h : decide (n < 0) = true
pos_invOf_d : 0 < ⅟↑d
⊢ e ≠ 0
state_after: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℤ
d : ℕ
inst✝ : LinearOrderedRing A
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h : decide (n < 0) = true
pos_invOf_d : 0 < ⅟↑d
neg_n : ↑n < 0
⊢ e ≠ 0
tactic: have neg_n : ((n : A) < 0) := Int.cast_lt_zero (n := n) |>.2 (of_decide_eq_true h)
state_before: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℤ
d : ℕ
inst✝ : LinearOrderedRing A
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h : decide (n < 0) = true
pos_invOf_d : 0 < ⅟↑d
neg_n : ↑n < 0
⊢ e ≠ 0
state_after: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℤ
d : ℕ
inst✝ : LinearOrderedRing A
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h : decide (n < 0) = true
pos_invOf_d : 0 < ⅟↑d
neg_n : ↑n < 0
neg : ↑n * ⅟↑d < 0
⊢ e ≠ 0
tactic: have neg := mul_neg_of_neg_of_pos neg_n pos_invOf_d
state_before: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℤ
d : ℕ
inst✝ : LinearOrderedRing A
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h : decide (n < 0) = true
pos_invOf_d : 0 < ⅟↑d
neg_n : ↑n < 0
neg : ↑n * ⅟↑d < 0
⊢ e ≠ 0
state_after: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℤ
d : ℕ
inst✝ : LinearOrderedRing A
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h : decide (n < 0) = true
pos_invOf_d : 0 < ⅟↑d
neg_n : ↑n < 0
neg : ↑n * ⅟↑d < 0
⊢ ↑n * ⅟↑d ≠ 0
tactic: rw [eq]
state_before: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℤ
d : ℕ
inst✝ : LinearOrderedRing A
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h : decide (n < 0) = true
pos_invOf_d : 0 < ⅟↑d
neg_n : ↑n < 0
neg : ↑n * ⅟↑d < 0
⊢ ↑n * ⅟↑d ≠ 0
state_after: no goals
tactic: exact ne_iff_lt_or_gt.2 (Or.inl neg)
Theorem: AlgebraicTopology.DoldKan.Compatibility.τ₁_hom_app
File: Mathlib/AlgebraicTopology/DoldKan/Compatibility.lean

Proof steps:
state_before: A : Type u_1
A' : Type u_2
B : Type u_3
B' : Type u_4
inst✝³ : Category.{?u.46256, u_1} A
inst✝² : Category.{?u.46260, u_2} A'
inst✝¹ : Category.{?u.46264, u_3} B
inst✝ : Category.{?u.46268, u_4} B'
eA : A ≌ A'
eB : B ≌ B'
e' : A' ≌ B'
F : A ⥤ B'
hF : eA.functor ⋙ e'.functor ≅ F
G : B ⥤ A
hG : eB.functor ⋙ e'.inverse ≅ G ⋙ eA.functor
η : G ⋙ F ≅ eB.functor
⊢ (G ⋙ eA.functor) ⋙ e'.functor ≅ G ⋙ eA.functor ⋙ e'.functor
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.whisker_eq
File: Mathlib/CategoryTheory/Category/Basic.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
g h : Y ⟶ Z
w : g = h
⊢ f ≫ g = f ≫ h
state_after: no goals
tactic: rw [w]
Theorem: map_comp_add
File: Mathlib/Algebra/Group/Hom/Defs.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F : Type u_9
inst✝³ : Mul M
inst✝² : Mul N
inst✝¹ : FunLike F M N
inst✝ : MulHomClass F M N
f : F
g h : ι → M
⊢ ⇑f ∘ (g * h) = ⇑f ∘ g * ⇑f ∘ h
state_after: case h
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F : Type u_9
inst✝³ : Mul M
inst✝² : Mul N
inst✝¹ : FunLike F M N
inst✝ : MulHomClass F M N
f : F
g h : ι → M
x✝ : ι
⊢ (⇑f ∘ (g * h)) x✝ = (⇑f ∘ g * ⇑f ∘ h) x✝
tactic: ext
state_before: case h
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F : Type u_9
inst✝³ : Mul M
inst✝² : Mul N
inst✝¹ : FunLike F M N
inst✝ : MulHomClass F M N
f : F
g h : ι → M
x✝ : ι
⊢ (⇑f ∘ (g * h)) x✝ = (⇑f ∘ g * ⇑f ∘ h) x✝
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Limits.Sigma.map'_eq
File: Mathlib/CategoryTheory/Limits/Shapes/Products.lean

Proof steps:
state_before: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝² : Category.{v, u} C
f : α → C
g : β → C
inst✝¹ : HasCoproduct f
inst✝ : HasCoproduct g
p p' : α → β
q : (a : α) → f a ⟶ g (p a)
q' : (a : α) → f a ⟶ g (p' a)
hp : p = p'
hq : ∀ (a : α), q a ≫ eqToHom ⋯ = q' a
⊢ map' p q = map' p' q'
state_after: no goals
tactic: aesop_cat
Theorem: Int.even_or_odd'
File: Mathlib/Algebra/Ring/Int.lean

Proof steps:
state_before: m n✝ n : ℤ
⊢ ∃ k, n = 2 * k ∨ n = 2 * k + 1
state_after: no goals
tactic: simpa only [two_mul, exists_or, Odd, Even] using even_or_odd n
Theorem: map_birkhoffAverage
File: Mathlib/Dynamics/BirkhoffSum/Average.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
M : Type u_3
inst✝⁷ : DivisionSemiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
S : Type u_4
F : Type u_5
N : Type u_6
inst✝⁴ : DivisionSemiring S
inst✝³ : AddCommMonoid N
inst✝² : Module S N
inst✝¹ : FunLike F M N
inst✝ : AddMonoidHomClass F M N
g' : F
f : α → α
g : α → M
n : ℕ
x : α
⊢ g' (birkhoffAverage R f g n x) = birkhoffAverage S f (⇑g' ∘ g) n x
state_after: no goals
tactic: simp only [birkhoffAverage, map_inv_natCast_smul g' R S, map_birkhoffSum]
Theorem: ProbabilityTheory.Kernel.mem_mutuallySingularSetSlice
File: Mathlib/Probability/Kernel/RadonNikodym.lean

Proof steps:
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : Kernel α γ
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : Kernel α γ
a : α
x : γ
⊢ x ∈ κ.mutuallySingularSetSlice η a ↔ 1 ≤ κ.rnDerivAux (κ + η) a x
state_after: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : Kernel α γ
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : Kernel α γ
a : α
x : γ
⊢ x ∈ {x | 1 ≤ κ.rnDerivAux (κ + η) a x} ↔ 1 ≤ κ.rnDerivAux (κ + η) a x
tactic: rw [mutuallySingularSetSlice]
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : Kernel α γ
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : Kernel α γ
a : α
x : γ
⊢ x ∈ {x | 1 ≤ κ.rnDerivAux (κ + η) a x} ↔ 1 ≤ κ.rnDerivAux (κ + η) a x
state_after: no goals
tactic: rfl
Theorem: FirstOrder.Language.Theory.IsMaximal.mem_of_models
File: Mathlib/ModelTheory/Satisfiability.lean

Proof steps:
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
h : T.IsMaximal
φ : L.Sentence
hφ : T ⊨ᵇ φ
⊢ φ ∈ T
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
h : T.IsMaximal
φ : L.Sentence
hφ : T ⊨ᵇ φ
con : Formula.not φ ∈ T
⊢ False
tactic: refine (h.mem_or_not_mem φ).resolve_right fun con => ?_
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
h : T.IsMaximal
φ : L.Sentence
hφ : T ⊨ᵇ φ
con : Formula.not φ ∈ T
⊢ False
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
h : T.IsMaximal
φ : L.Sentence
hφ : ¬T.IsSatisfiable
con : Formula.not φ ∈ T
⊢ False
tactic: rw [models_iff_not_satisfiable, Set.union_singleton, Set.insert_eq_of_mem con] at hφ
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
h : T.IsMaximal
φ : L.Sentence
hφ : ¬T.IsSatisfiable
con : Formula.not φ ∈ T
⊢ False
state_after: no goals
tactic: exact hφ h.1
Theorem: IsSl2Triple.lie_lie_smul_f
File: Mathlib/Algebra/Lie/Sl2.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
h e f : L
t : IsSl2Triple h e f
⊢ ⁅h, f⁆ = -(2 • f)
state_after: no goals
tactic: simp [t.lie_h_f_nsmul, two_smul]
Theorem: Equiv.setOf_apply_symm_eq_image_setOf
File: Mathlib/Logic/Equiv/Set.lean

Proof steps:
state_before: α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
e : α ≃ β
p : α → Prop
⊢ {b | p (e.symm b)} = ⇑e '' {a | p a}
state_after: no goals
tactic: rw [Equiv.image_eq_preimage, preimage_setOf_eq]
Theorem: Nat.Prime.eq_of_factorization_pos
File: Mathlib/Data/Nat/Factorization/Basic.lean

Proof steps:
state_before: a b m n p✝ p q : ℕ
hp : Prime p
h : p.factorization q ≠ 0
⊢ p = q
state_after: no goals
tactic: simpa [hp.factorization, single_apply] using h
Theorem: Polynomial.degree_map_le
File: Mathlib/Algebra/Polynomial/Eval.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p✝ q r : R[X]
inst✝ : Semiring S
f : R →+* S
p : R[X]
⊢ (map f p).degree ≤ p.degree
state_after: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m✝ n : ℕ
inst✝¹ : Semiring R
p✝ q r : R[X]
inst✝ : Semiring S
f : R →+* S
p : R[X]
m : ℕ
hm : p.degree < ↑m
⊢ (map f p).coeff m = 0
tactic: refine (degree_le_iff_coeff_zero _ _).2 fun m hm => ?_
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m✝ n : ℕ
inst✝¹ : Semiring R
p✝ q r : R[X]
inst✝ : Semiring S
f : R →+* S
p : R[X]
m : ℕ
hm : p.degree < ↑m
⊢ (map f p).coeff m = 0
state_after: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m✝ n : ℕ
inst✝¹ : Semiring R
p✝ q r : R[X]
inst✝ : Semiring S
f : R →+* S
p : R[X]
m : ℕ
hm : ∀ (m_1 : ℕ), m ≤ m_1 → p.coeff m_1 = 0
⊢ (map f p).coeff m = 0
tactic: rw [degree_lt_iff_coeff_zero] at hm
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m✝ n : ℕ
inst✝¹ : Semiring R
p✝ q r : R[X]
inst✝ : Semiring S
f : R →+* S
p : R[X]
m : ℕ
hm : ∀ (m_1 : ℕ), m ≤ m_1 → p.coeff m_1 = 0
⊢ (map f p).coeff m = 0
state_after: no goals
tactic: simp [hm m le_rfl]
Theorem: List.Nat.map_swap_antidiagonal
File: Mathlib/Data/List/NatAntidiagonal.lean

Proof steps:
state_before: n : ℕ
⊢ map Prod.swap (antidiagonal n) = (antidiagonal n).reverse
state_after: n : ℕ
⊢ map (Prod.swap ∘ fun i => (i, n - i)) (range (n + 1)) =
    map ((fun i => (i, n - i)) ∘ fun x => 0 + (n + 1) - 1 - x) (range (n + 1))
tactic: rw [antidiagonal, map_map, ← List.map_reverse, range_eq_range', reverse_range', ←
    range_eq_range', map_map]
state_before: n : ℕ
⊢ map (Prod.swap ∘ fun i => (i, n - i)) (range (n + 1)) =
    map ((fun i => (i, n - i)) ∘ fun x => 0 + (n + 1) - 1 - x) (range (n + 1))
state_after: case h
n : ℕ
⊢ ∀ a ∈ range (n + 1), (Prod.swap ∘ fun i => (i, n - i)) a = ((fun i => (i, n - i)) ∘ fun x => 0 + (n + 1) - 1 - x) a
tactic: apply map_congr_left
state_before: case h
n : ℕ
⊢ ∀ a ∈ range (n + 1), (Prod.swap ∘ fun i => (i, n - i)) a = ((fun i => (i, n - i)) ∘ fun x => 0 + (n + 1) - 1 - x) a
state_after: no goals
tactic: simp (config := { contextual := true }) [Nat.sub_sub_self, Nat.lt_succ_iff]
Theorem: Polynomial.X_pow_add_C_ne_one
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝¹ : Nontrivial R
inst✝ : Semiring R
n : ℕ
hn : 0 < n
a : R
h : X ^ n + C a = 1
⊢ n = 0
state_after: no goals
tactic: simpa only [natDegree_X_pow_add_C, natDegree_one] using congr_arg natDegree h
Theorem: Equiv.Perm.isCycle_iff_sameCycle
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y✝ : α
hx : f x ≠ x
hf : f.IsCycle
y : α
x✝ : f.SameCycle x y
hy : f y = y
i : ℤ
hi : (f ^ i) x = y
⊢ f x = x
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y✝ : α
hx : f x ≠ x
hf : f.IsCycle
y : α
x✝ : f.SameCycle x y
hy : f y = y
i : ℤ
hi : x = y
⊢ f x = x
tactic: rw [← zpow_apply_eq_self_of_apply_eq_self hy i, (f ^ i).injective.eq_iff] at hi
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y✝ : α
hx : f x ≠ x
hf : f.IsCycle
y : α
x✝ : f.SameCycle x y
hy : f y = y
i : ℤ
hi : x = y
⊢ f x = x
state_after: no goals
tactic: rw [hi, hy]
Theorem: le_of_forall_one_lt_div_le
File: Mathlib/Algebra/Order/Group/DenselyOrdered.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : Group α
inst✝² : LinearOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : DenselyOrdered α
a b c : α
h : ∀ (ε : α), 1 < ε → a / ε ≤ b
ε : α
ε1 : ε < 1
⊢ a * ε ≤ b
state_after: no goals
tactic: simpa only [div_eq_mul_inv, inv_inv] using h ε⁻¹ (Left.one_lt_inv_iff.2 ε1)
Theorem: Ordinal.div_mul_cancel
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal.{u_4}
a0 : a ≠ 0
b : Ordinal.{u_4}
⊢ a * (a * b / a) = a * b
state_after: no goals
tactic: rw [mul_div_cancel _ a0]
Theorem: monovary_iff_forall_mul_nonneg
File: Mathlib/Algebra/Order/Monovary.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedRing α
f g : ι → α
s : Set ι
a b c d : α
⊢ Monovary f g ↔ ∀ (i j : ι), 0 ≤ (f j - f i) * (g j - g i)
state_after: no goals
tactic: simp only [smul_eq_mul, monovary_iff_forall_smul_nonneg]
Theorem: List.leftpad_prefix
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
n : Nat
a : α
l : List α
⊢ replicate (n - l.length) a <+: leftpad n a l
state_after: α : Type u_1
n : Nat
a : α
l : List α
⊢ ∃ t, replicate (n - l.length) a ++ t = replicate (n - l.length) a ++ l
tactic: simp only [IsPrefix, leftpad]
state_before: α : Type u_1
n : Nat
a : α
l : List α
⊢ ∃ t, replicate (n - l.length) a ++ t = replicate (n - l.length) a ++ l
state_after: no goals
tactic: exact Exists.intro l rfl
Theorem: Irreducible.not_square
File: Mathlib/Algebra/Associated/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
a : α
ha : Irreducible a
⊢ ¬IsSquare a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
a : α
ha : Irreducible a
⊢ ¬∃ c, a = c ^ 2
tactic: rw [isSquare_iff_exists_sq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
a : α
ha : Irreducible a
⊢ ¬∃ c, a = c ^ 2
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
b : α
ha : Irreducible (b ^ 2)
⊢ False
tactic: rintro ⟨b, rfl⟩
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
b : α
ha : Irreducible (b ^ 2)
⊢ False
state_after: no goals
tactic: exact not_irreducible_pow (by decide) ha
Theorem: ContinuousOn.comp_continuous
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
g : β → γ
f : α → β
s : Set β
hg : ContinuousOn g s
hf : Continuous f
hs : ∀ (x : α), f x ∈ s
⊢ Continuous (g ∘ f)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
g : β → γ
f : α → β
s : Set β
hg : ContinuousOn g s
hf : ContinuousOn f univ
hs : ∀ (x : α), f x ∈ s
⊢ ContinuousOn (g ∘ f) univ
tactic: rw [continuous_iff_continuousOn_univ] at *
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
g : β → γ
f : α → β
s : Set β
hg : ContinuousOn g s
hf : ContinuousOn f univ
hs : ∀ (x : α), f x ∈ s
⊢ ContinuousOn (g ∘ f) univ
state_after: no goals
tactic: exact hg.comp hf fun x _ => hs x
Theorem: AddChar.sum_eq_card_of_eq_one
File: Mathlib/NumberTheory/LegendreSymbol/AddCharacter.lean

Proof steps:
state_before: R : Type u_1
inst✝² : AddGroup R
inst✝¹ : Fintype R
R' : Type u_2
inst✝ : CommRing R'
ψ : AddChar R R'
hψ : ψ = 1
⊢ ∑ a : R, ψ a = ↑(Fintype.card R)
state_after: no goals
tactic: simp [hψ]
Theorem: IsAdjoinRootMonic.map_modByMonic
File: Mathlib/RingTheory/IsAdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : R[X]
⊢ h.map (g %ₘ f) = h.map g
state_after: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : R[X]
⊢ f ∣ f * (g /ₘ f)
tactic: rw [← RingHom.sub_mem_ker_iff, mem_ker_map, modByMonic_eq_sub_mul_div _ h.Monic, sub_right_comm,
    sub_self, zero_sub, dvd_neg]
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : R[X]
⊢ f ∣ f * (g /ₘ f)
state_after: no goals
tactic: exact ⟨_, rfl⟩
Theorem: mul_eq_one_iff'
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : MulOneClass α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
ha : 1 ≤ a
hb : 1 ≤ b
⊢ a = 1 ∧ b = 1 → a * b = 1
state_after: case intro
α : Type u_1
β : Type u_2
inst✝³ : MulOneClass α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
ha hb : 1 ≤ 1
⊢ 1 * 1 = 1
tactic: rintro ⟨rfl, rfl⟩
state_before: case intro
α : Type u_1
β : Type u_2
inst✝³ : MulOneClass α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
ha hb : 1 ≤ 1
⊢ 1 * 1 = 1
state_after: no goals
tactic: rw [mul_one]
Theorem: Set.Ioo_inter_Ioo
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ Ioo a₁ b₁ ∩ Ioo a₂ b₂ = Ioo (a₁ ⊔ a₂) (b₁ ⊓ b₂)
state_after: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ Ioi a₁ ∩ Iio b₁ ∩ (Ioi a₂ ∩ Iio b₂) = Ioi a₁ ∩ Ioi a₂ ∩ (Iio b₁ ∩ Iio b₂)
tactic: simp only [Ioi_inter_Iio.symm, Ioi_inter_Ioi.symm, Iio_inter_Iio.symm]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ Ioi a₁ ∩ Iio b₁ ∩ (Ioi a₂ ∩ Iio b₂) = Ioi a₁ ∩ Ioi a₂ ∩ (Iio b₁ ∩ Iio b₂)
state_after: no goals
tactic: ac_rfl
Theorem: ContinuousWithinAt.finset_sup
File: Mathlib/Topology/Order/Lattice.lean

Proof steps:
state_before: L : Type u_1
X : Type u_2
inst✝⁴ : TopologicalSpace L
inst✝³ : TopologicalSpace X
ι : Type u_3
inst✝² : SemilatticeSup L
inst✝¹ : OrderBot L
inst✝ : ContinuousSup L
s : Finset ι
f : ι → X → L
t : Set X
x : X
hs : ∀ i ∈ s, ContinuousWithinAt (f i) t x
⊢ ContinuousWithinAt (s.sup f) t x
state_after: no goals
tactic: simpa only [← Finset.sup_apply] using finset_sup_apply hs
Theorem: PiLp.norm_equiv_symm_const
File: Mathlib/Analysis/Normed/Lp/PiLp.lean

Proof steps:
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝⁷ : Fact (1 ≤ p)
inst✝⁶ : Fintype ι
inst✝⁵ : Semiring 𝕜
inst✝⁴ : (i : ι) → SeminormedAddCommGroup (α i)
inst✝³ : (i : ι) → SeminormedAddCommGroup (β✝ i)
inst✝² : (i : ι) → Module 𝕜 (α i)
inst✝¹ : (i : ι) → Module 𝕜 (β✝ i)
c : 𝕜
β : Type u_5
inst✝ : SeminormedAddCommGroup β
hp : p ≠ ⊤
b : β
⊢ ↑(↑(Fintype.card ι) ^ (1 / p).toReal * ‖b‖₊) = ↑↑(Fintype.card ι) ^ (1 / p).toReal * ‖b‖
state_after: no goals
tactic: simp
Theorem: MeasureTheory.exists_null_frontiers_thickening
File: Mathlib/MeasureTheory/Measure/Portmanteau.lean

Proof steps:
state_before: Ω : Type u_1
inst✝³ : PseudoEMetricSpace Ω
inst✝² : MeasurableSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : SFinite μ
s : Set Ω
⊢ ∃ rs, Tendsto rs atTop (𝓝 0) ∧ ∀ (n : ℕ), 0 < rs n ∧ μ (frontier (Metric.thickening (rs n) s)) = 0
state_after: case intro.intro.intro
Ω : Type u_1
inst✝³ : PseudoEMetricSpace Ω
inst✝² : MeasurableSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : SFinite μ
s : Set Ω
Rs : ℕ → ℝ
left✝ : StrictAnti Rs
Rs_pos : ∀ (n : ℕ), 0 < Rs n
Rs_lim : Tendsto Rs atTop (𝓝 0)
⊢ ∃ rs, Tendsto rs atTop (𝓝 0) ∧ ∀ (n : ℕ), 0 < rs n ∧ μ (frontier (Metric.thickening (rs n) s)) = 0
tactic: rcases exists_seq_strictAnti_tendsto (0 : ℝ) with ⟨Rs, ⟨_, ⟨Rs_pos, Rs_lim⟩⟩⟩
state_before: case intro.intro.intro
Ω : Type u_1
inst✝³ : PseudoEMetricSpace Ω
inst✝² : MeasurableSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : SFinite μ
s : Set Ω
Rs : ℕ → ℝ
left✝ : StrictAnti Rs
Rs_pos : ∀ (n : ℕ), 0 < Rs n
Rs_lim : Tendsto Rs atTop (𝓝 0)
⊢ ∃ rs, Tendsto rs atTop (𝓝 0) ∧ ∀ (n : ℕ), 0 < rs n ∧ μ (frontier (Metric.thickening (rs n) s)) = 0
state_after: case intro.intro.intro
Ω : Type u_1
inst✝³ : PseudoEMetricSpace Ω
inst✝² : MeasurableSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : SFinite μ
s : Set Ω
Rs : ℕ → ℝ
left✝ : StrictAnti Rs
Rs_pos : ∀ (n : ℕ), 0 < Rs n
Rs_lim : Tendsto Rs atTop (𝓝 0)
obs : ∀ (n : ℕ), ∃ r ∈ Ioo 0 (Rs n), μ (frontier (Metric.thickening r s)) = 0
⊢ ∃ rs, Tendsto rs atTop (𝓝 0) ∧ ∀ (n : ℕ), 0 < rs n ∧ μ (frontier (Metric.thickening (rs n) s)) = 0
tactic: have obs := fun n : ℕ => exists_null_frontier_thickening μ s (Rs_pos n)
state_before: case intro.intro.intro
Ω : Type u_1
inst✝³ : PseudoEMetricSpace Ω
inst✝² : MeasurableSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : SFinite μ
s : Set Ω
Rs : ℕ → ℝ
left✝ : StrictAnti Rs
Rs_pos : ∀ (n : ℕ), 0 < Rs n
Rs_lim : Tendsto Rs atTop (𝓝 0)
obs : ∀ (n : ℕ), ∃ r ∈ Ioo 0 (Rs n), μ (frontier (Metric.thickening r s)) = 0
⊢ ∃ rs, Tendsto rs atTop (𝓝 0) ∧ ∀ (n : ℕ), 0 < rs n ∧ μ (frontier (Metric.thickening (rs n) s)) = 0
state_after: case intro.intro.intro.refine_1
Ω : Type u_1
inst✝³ : PseudoEMetricSpace Ω
inst✝² : MeasurableSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : SFinite μ
s : Set Ω
Rs : ℕ → ℝ
left✝ : StrictAnti Rs
Rs_pos : ∀ (n : ℕ), 0 < Rs n
Rs_lim : Tendsto Rs atTop (𝓝 0)
obs : ∀ (n : ℕ), ∃ r ∈ Ioo 0 (Rs n), μ (frontier (Metric.thickening r s)) = 0
⊢ Tendsto (fun n => ⋯.choose) atTop (𝓝 0)

case intro.intro.intro.refine_2
Ω : Type u_1
inst✝³ : PseudoEMetricSpace Ω
inst✝² : MeasurableSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : SFinite μ
s : Set Ω
Rs : ℕ → ℝ
left✝ : StrictAnti Rs
Rs_pos : ∀ (n : ℕ), 0 < Rs n
Rs_lim : Tendsto Rs atTop (𝓝 0)
obs : ∀ (n : ℕ), ∃ r ∈ Ioo 0 (Rs n), μ (frontier (Metric.thickening r s)) = 0
⊢ ∀ (n : ℕ), 0 < (fun n => ⋯.choose) n ∧ μ (frontier (Metric.thickening ((fun n => ⋯.choose) n) s)) = 0
tactic: refine ⟨fun n : ℕ => (obs n).choose, ⟨?_, ?_⟩⟩
Theorem: FirstOrder.Language.Structure.cg_iff_countable
File: Mathlib/ModelTheory/FinitelyGenerated.lean

Proof steps:
state_before: L : Language
M : Type u_1
inst✝¹ : L.Structure M
inst✝ : Countable ((l : ℕ) × L.Functions l)
⊢ CG L M ↔ Countable M
state_after: no goals
tactic: rw [cg_def, Substructure.cg_iff_countable, topEquiv.toEquiv.countable_iff]
Theorem: eq_ratCast
File: Mathlib/Data/Rat/Cast/Defs.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝³ : FunLike F α β
inst✝² : DivisionRing α
inst✝¹ : FunLike F ℚ α
inst✝ : RingHomClass F ℚ α
f : F
q : ℚ
⊢ f q = ↑q
state_after: no goals
tactic: rw [← map_ratCast f, Rat.cast_id]
Theorem: Filter.liminf_bot
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteLattice α
f : β → α
⊢ liminf f ⊥ = ⊤
state_after: no goals
tactic: simp [liminf]
Theorem: Cardinal.mul_eq_left
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: a b : Cardinal.{u_1}
ha : ℵ₀ ≤ a
hb : b ≤ a
hb' : b ≠ 0
⊢ a * b = a
state_after: no goals
tactic: rw [mul_eq_max_of_aleph0_le_left ha hb', max_eq_left hb]