ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: surjOn_Ico_of_monotone_surjective
File: Mathlib/Order/Interval/Set/SurjOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a b : α
⊢ SurjOn f (Ico a b) (Ico (f a) (f b))
state_after: case inl
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a b : α
hab : a < b
⊢ SurjOn f (Ico a b) (Ico (f a) (f b))

case inr
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a b : α
hab : b ≤ a
⊢ SurjOn f (Ico a b) (Ico (f a) (f b))
tactic: obtain hab | hab := lt_or_le a b
Theorem: Homeomorph.isConnected_preimage
File: Mathlib/Topology/Homeomorph.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
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
s : Set Y
h : X ≃ₜ Y
⊢ IsConnected (⇑h ⁻¹' s) ↔ IsConnected s
state_after: no goals
tactic: rw [← image_symm, isConnected_image]
Theorem: Filter.eq_biInf_of_mem_iff_exists_mem
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
p : ι → Prop
l : Filter α
h : ∀ {s : Set α}, s ∈ l ↔ ∃ i, p i ∧ s ∈ f i
⊢ l = ⨅ i, ⨅ (_ : p i), f i
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
p : ι → Prop
l : Filter α
h : ∀ {s : Set α}, s ∈ l ↔ ∃ i, p i ∧ s ∈ f i
⊢ l = ⨅ x, f ↑x
tactic: rw [iInf_subtype']
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
p : ι → Prop
l : Filter α
h : ∀ {s : Set α}, s ∈ l ↔ ∃ i, p i ∧ s ∈ f i
⊢ l = ⨅ x, f ↑x
state_after: no goals
tactic: exact eq_iInf_of_mem_iff_exists_mem fun {_} => by simp only [Subtype.exists, h, exists_prop]
Theorem: Matrix.one_fin_two
File: Mathlib/Data/Matrix/Notation.lean

Proof steps:
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : Zero α
inst✝ : One α
⊢ 1 = !![1, 0; 0, 1]
state_after: case a
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : Zero α
inst✝ : One α
i j : Fin 2
⊢ 1 i j = !![1, 0; 0, 1] i j
tactic: ext i j
state_before: case a
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : Zero α
inst✝ : One α
i j : Fin 2
⊢ 1 i j = !![1, 0; 0, 1] i j
state_after: no goals
tactic: fin_cases i <;> fin_cases j <;> rfl
Theorem: MultilinearMap.cons_smul
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

Proof steps:
state_before: R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹⁰ : Semiring R
inst✝⁹ : (i : Fin n.succ) → AddCommMonoid (M i)
inst✝⁸ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : (i : Fin n.succ) → Module R (M i)
inst✝³ : (i : ι) → Module R (M₁ i)
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M'
f✝ f' : MultilinearMap R M₁ M₂
f : MultilinearMap R M M₂
m : (i : Fin n) → M i.succ
c : R
x : M 0
⊢ f (cons (c • x) m) = c • f (cons x m)
state_after: no goals
tactic: simp_rw [← update_cons_zero x m (c • x), f.map_smul, update_cons_zero]
Theorem: norm_indicator_le_norm_self
File: Mathlib/Analysis/NormedSpace/IndicatorFunction.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
inst✝ : SeminormedAddCommGroup E
s t : Set α
f : α → E
a : α
⊢ ‖s.indicator f a‖ ≤ ‖f a‖
state_after: α : Type u_1
E : Type u_2
inst✝ : SeminormedAddCommGroup E
s t : Set α
f : α → E
a : α
⊢ s.indicator (fun a => ‖f a‖) a ≤ ‖f a‖
tactic: rw [norm_indicator_eq_indicator_norm]
state_before: α : Type u_1
E : Type u_2
inst✝ : SeminormedAddCommGroup E
s t : Set α
f : α → E
a : α
⊢ s.indicator (fun a => ‖f a‖) a ≤ ‖f a‖
state_after: no goals
tactic: apply indicator_norm_le_norm_self
Theorem: finrank_span_le_card
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

Proof steps:
state_before: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁹ : Ring R
inst✝⁸ : CommRing S
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : StrongRankCondition R
s : Set M
inst✝ : Fintype ↑s
⊢ Module.rank R ↥(span R s) ≤ ↑s.toFinset.card
state_after: no goals
tactic: simpa using rank_span_le (R := R) s
Theorem: le_inv_of_neg
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
ha : a < 0
hb : b < 0
⊢ a ≤ b⁻¹ ↔ b ≤ a⁻¹
state_after: no goals
tactic: rw [← inv_le_inv_of_neg (inv_lt_zero (α := α) |>.2 hb) ha, inv_inv]
Theorem: Summable.tsum_vanishing
File: Mathlib/Topology/Algebra/InfiniteSum/Group.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
G : Type u_5
inst✝² : TopologicalSpace G
inst✝¹ : CommGroup G
inst✝ : TopologicalGroup G
f : α → G
hf : Multipliable f
e : Set G
he : e ∈ 𝓝 1
⊢ ∃ s, ∀ (t : Set α), Disjoint t ↑s → ∏' (b : ↑t), f ↑b ∈ e
state_after: no goals
tactic: classical
  letI : UniformSpace G := TopologicalGroup.toUniformSpace G
  have : UniformGroup G := comm_topologicalGroup_is_uniform
  exact cauchySeq_finset_iff_tprod_vanishing.1 hf.hasProd.cauchySeq e he
Theorem: FirstOrder.Language.Substructure.realize_formula_top
File: Mathlib/ModelTheory/Substructures.lean

Proof steps:
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
s : Set M
α : Type u_3
φ : L.Formula α
v : α → ↥⊤
⊢ φ.Realize v ↔ φ.Realize (Subtype.val ∘ v)
state_after: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
s : Set M
α : Type u_3
φ : L.Formula α
v : α → ↥⊤
⊢ φ.Realize (⇑topEquiv ∘ v) ↔ φ.Realize (Subtype.val ∘ v)
tactic: rw [← Substructure.topEquiv.realize_formula φ]
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
s : Set M
α : Type u_3
φ : L.Formula α
v : α → ↥⊤
⊢ φ.Realize (⇑topEquiv ∘ v) ↔ φ.Realize (Subtype.val ∘ v)
state_after: no goals
tactic: simp
Theorem: mem_maximals_iff_forall_lt_not_mem'
File: Mathlib/Order/Minimal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a b x : α
rlt : α → α → Prop
inst✝ : IsNonstrictStrictOrder α r rlt
⊢ x ∈ maximals r s ↔ x ∈ s ∧ ∀ ⦃y : α⦄, rlt x y → y ∉ s
state_after: no goals
tactic: simp [maximals, right_iff_left_not_left_of r rlt, not_imp_not, imp.swap (a := _ ∈ _)]
Theorem: MvPolynomial.C_surjective
File: Mathlib/Algebra/MvPolynomial/Basic.lean

Proof steps:
state_before: R✝ : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ✝ : Type u_1
a a' a₁ a₂ : R✝
e : ℕ
n m : σ✝
s : σ✝ →₀ ℕ
inst✝³ : CommSemiring R✝
inst✝² : CommSemiring S₁
p q : MvPolynomial σ✝ R✝
R : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : IsEmpty σ
⊢ Surjective ⇑C
state_after: R✝ : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ✝ : Type u_1
a✝ a' a₁ a₂ : R✝
e : ℕ
n m : σ✝
s : σ✝ →₀ ℕ
inst✝³ : CommSemiring R✝
inst✝² : CommSemiring S₁
p✝ q : MvPolynomial σ✝ R✝
R : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : IsEmpty σ
p : MvPolynomial σ R
a : σ →₀ ℕ
⊢ (C (p.toFun 0)) a = p a
tactic: refine fun p => ⟨p.toFun 0, Finsupp.ext fun a => ?_⟩
state_before: R✝ : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ✝ : Type u_1
a✝ a' a₁ a₂ : R✝
e : ℕ
n m : σ✝
s : σ✝ →₀ ℕ
inst✝³ : CommSemiring R✝
inst✝² : CommSemiring S₁
p✝ q : MvPolynomial σ✝ R✝
R : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : IsEmpty σ
p : MvPolynomial σ R
a : σ →₀ ℕ
⊢ (C (p.toFun 0)) a = p a
state_after: R✝ : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ✝ : Type u_1
a✝ a' a₁ a₂ : R✝
e : ℕ
n m : σ✝
s : σ✝ →₀ ℕ
inst✝³ : CommSemiring R✝
inst✝² : CommSemiring S₁
p✝ q : MvPolynomial σ✝ R✝
R : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : IsEmpty σ
p : MvPolynomial σ R
a : σ →₀ ℕ
⊢ p.toFun 0 = p 0
tactic: simp only [C_apply, ← single_eq_monomial, (Finsupp.ext isEmptyElim (α := σ) : a = 0),
    single_eq_same]
state_before: R✝ : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ✝ : Type u_1
a✝ a' a₁ a₂ : R✝
e : ℕ
n m : σ✝
s : σ✝ →₀ ℕ
inst✝³ : CommSemiring R✝
inst✝² : CommSemiring S₁
p✝ q : MvPolynomial σ✝ R✝
R : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : IsEmpty σ
p : MvPolynomial σ R
a : σ →₀ ℕ
⊢ p.toFun 0 = p 0
state_after: no goals
tactic: rfl
Theorem: Equiv.boolProdNatEquivNat_apply
File: Mathlib/Logic/Equiv/Nat.lean

Proof steps:
state_before: α : Type u_1
x✝ : Bool × ℕ
b : Bool
n : ℕ
⊢ (uncurry bit (b, n)).boddDiv2 = (b, n)
state_after: no goals
tactic: simp only [bodd_bit, div2_bit, uncurry_apply_pair, boddDiv2_eq]
state_before: α : Type u_1
n : ℕ
⊢ uncurry bit n.boddDiv2 = n
state_after: no goals
tactic: simp only [bit_decomp, boddDiv2_eq, uncurry_apply_pair]
Theorem: CategoryTheory.SimplicialObject.augment_left
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ X : SimplicialObject C
X₀ : C
f : X _[0] ⟶ X₀
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f
⊢ ∀ ⦃X_1 Y : SimplexCategoryᵒᵖ⦄ (f_1 : X_1 ⟶ Y),
    ((𝟭 (SimplicialObject C)).obj X).map f_1 ≫ (fun i => X.map ([0].const (unop i) 0).op ≫ f) Y =
      (fun i => X.map ([0].const (unop i) 0).op ≫ f) X_1 ≫ ((const C).obj X₀).map f_1
state_after: C : Type u
inst✝ : Category.{v, u} C
X✝ X : SimplicialObject C
X₀ : C
f : X _[0] ⟶ X₀
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f
i j : SimplexCategoryᵒᵖ
g : i ⟶ j
⊢ ((𝟭 (SimplicialObject C)).obj X).map g ≫ (fun i => X.map ([0].const (unop i) 0).op ≫ f) j =
    (fun i => X.map ([0].const (unop i) 0).op ≫ f) i ≫ ((const C).obj X₀).map g
tactic: intro i j g
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ X : SimplicialObject C
X₀ : C
f : X _[0] ⟶ X₀
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f
i j : SimplexCategoryᵒᵖ
g : i ⟶ j
⊢ ((𝟭 (SimplicialObject C)).obj X).map g ≫ (fun i => X.map ([0].const (unop i) 0).op ≫ f) j =
    (fun i => X.map ([0].const (unop i) 0).op ≫ f) i ≫ ((const C).obj X₀).map g
state_after: C : Type u
inst✝ : Category.{v, u} C
X✝ X : SimplicialObject C
X₀ : C
f : X _[0] ⟶ X₀
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f
i j : SimplexCategoryᵒᵖ
g : i ⟶ j
⊢ X.map g ≫ X.map ([0].const (unop j) 0).op ≫ f = (X.map ([0].const (unop i) 0).op ≫ f) ≫ 𝟙 X₀
tactic: dsimp
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ X : SimplicialObject C
X₀ : C
f : X _[0] ⟶ X₀
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f
i j : SimplexCategoryᵒᵖ
g : i ⟶ j
⊢ X.map g ≫ X.map ([0].const (unop j) 0).op ≫ f = (X.map ([0].const (unop i) 0).op ≫ f) ≫ 𝟙 X₀
state_after: C : Type u
inst✝ : Category.{v, u} C
X✝ X : SimplicialObject C
X₀ : C
f : X _[0] ⟶ X₀
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f
i j : SimplexCategoryᵒᵖ
g : i ⟶ j
⊢ X.map g.unop.op ≫ X.map ([0].const (unop j) 0).op ≫ f = (X.map ([0].const (unop i) 0).op ≫ f) ≫ 𝟙 X₀
tactic: rw [← g.op_unop]
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ X : SimplicialObject C
X₀ : C
f : X _[0] ⟶ X₀
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f
i j : SimplexCategoryᵒᵖ
g : i ⟶ j
⊢ X.map g.unop.op ≫ X.map ([0].const (unop j) 0).op ≫ f = (X.map ([0].const (unop i) 0).op ≫ f) ≫ 𝟙 X₀
state_after: no goals
tactic: simpa only [← X.map_comp, ← Category.assoc, Category.comp_id, ← op_comp] using w _ _ _
Theorem: Turing.tr_reaches
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
b₁ : σ₁
ab : Reaches f₁ a₁ b₁
⊢ ∃ b₂, tr b₁ b₂ ∧ Reaches f₂ a₂ b₂
state_after: case inl
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₂ : σ₂
b₁ : σ₁
aa : tr b₁ a₂
ab : Reaches f₁ b₁ b₁
⊢ ∃ b₂, tr b₁ b₂ ∧ Reaches f₂ a₂ b₂

case inr
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
b₁ : σ₁
ab✝ : Reaches f₁ a₁ b₁
ab : TransGen (fun a b => b ∈ f₁ a) a₁ b₁
⊢ ∃ b₂, tr b₁ b₂ ∧ Reaches f₂ a₂ b₂
tactic: rcases reflTransGen_iff_eq_or_transGen.1 ab with (rfl | ab)
Theorem: LSeries.norm_term_le
File: Mathlib/NumberTheory/LSeries/Basic.lean

Proof steps:
state_before: f g : ℕ → ℂ
s : ℂ
n : ℕ
h : ‖f n‖ ≤ ‖g n‖
⊢ ‖term f s n‖ ≤ ‖term g s n‖
state_after: f g : ℕ → ℂ
s : ℂ
n : ℕ
h : ‖f n‖ ≤ ‖g n‖
⊢ (if n = 0 then 0 else ‖f n‖ / ↑n ^ s.re) ≤ if n = 0 then 0 else ‖g n‖ / ↑n ^ s.re
tactic: simp only [norm_term_eq]
state_before: f g : ℕ → ℂ
s : ℂ
n : ℕ
h : ‖f n‖ ≤ ‖g n‖
⊢ (if n = 0 then 0 else ‖f n‖ / ↑n ^ s.re) ≤ if n = 0 then 0 else ‖g n‖ / ↑n ^ s.re
state_after: case isTrue
f g : ℕ → ℂ
s : ℂ
n : ℕ
h : ‖f n‖ ≤ ‖g n‖
h✝ : n = 0
⊢ 0 ≤ 0

case isFalse
f g : ℕ → ℂ
s : ℂ
n : ℕ
h : ‖f n‖ ≤ ‖g n‖
h✝ : ¬n = 0
⊢ ‖f n‖ / ↑n ^ s.re ≤ ‖g n‖ / ↑n ^ s.re
tactic: split
Theorem: Complex.I_mul
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: z : ℂ
⊢ (I * z).re = { re := -z.im, im := z.re }.re ∧ (I * z).im = { re := -z.im, im := z.re }.im
state_after: no goals
tactic: simp
Theorem: range_two_mul
File: Mathlib/Algebra/Ring/Parity.lean

Proof steps:
state_before: F : Type u_1
α✝ : Type u_2
β : Type u_3
R : Type u_4
inst✝² : Semiring α✝
inst✝¹ : Semiring β
a b : α✝
m n : ℕ
α : Type u_5
inst✝ : Semiring α
⊢ (Set.range fun x => 2 * x) = {a | Even a}
state_after: case h
F : Type u_1
α✝ : Type u_2
β : Type u_3
R : Type u_4
inst✝² : Semiring α✝
inst✝¹ : Semiring β
a b : α✝
m n : ℕ
α : Type u_5
inst✝ : Semiring α
x : α
⊢ (x ∈ Set.range fun x => 2 * x) ↔ x ∈ {a | Even a}
tactic: ext x
state_before: case h
F : Type u_1
α✝ : Type u_2
β : Type u_3
R : Type u_4
inst✝² : Semiring α✝
inst✝¹ : Semiring β
a b : α✝
m n : ℕ
α : Type u_5
inst✝ : Semiring α
x : α
⊢ (x ∈ Set.range fun x => 2 * x) ↔ x ∈ {a | Even a}
state_after: no goals
tactic: simp [eq_comm, two_mul, Even]
Theorem: FirstOrder.Language.Substructure.lift_card_closure_le
File: Mathlib/ModelTheory/Substructures.lean

Proof steps:
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
s : Set M
⊢ lift.{u, w} #↥((closure L).toFun s) ≤ max ℵ₀ (lift.{u, w} #↑s + lift.{w, u} #((i : ℕ) × L.Functions i))
state_after: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
s : Set M
⊢ lift.{max w u, w} #↥((closure L).toFun s) ≤ max ℵ₀ (lift.{max w u, w} #↑s + lift.{w, u} #((i : ℕ) × L.Functions i))
tactic: rw [← lift_umax]
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
s : Set M
⊢ lift.{max w u, w} #↥((closure L).toFun s) ≤ max ℵ₀ (lift.{max w u, w} #↑s + lift.{w, u} #((i : ℕ) × L.Functions i))
state_after: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
s : Set M
⊢ max ℵ₀ #(↑s ⊕ (i : ℕ) × L.Functions i) ≤ max ℵ₀ (lift.{max w u, w} #↑s + lift.{w, u} #((i : ℕ) × L.Functions i))
tactic: refine lift_card_closure_le_card_term.trans (Term.card_le.trans ?_)
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
s : Set M
⊢ max ℵ₀ #(↑s ⊕ (i : ℕ) × L.Functions i) ≤ max ℵ₀ (lift.{max w u, w} #↑s + lift.{w, u} #((i : ℕ) × L.Functions i))
state_after: no goals
tactic: rw [mk_sum, lift_umax.{w, u}]
Theorem: VAddAssocClass.of_vadd_zero_add
File: Mathlib/Algebra/Group/Action/Defs.lean

Proof steps:
state_before: M✝ : Type u_1
N✝ : Type u_2
G : Type u_3
H : Type u_4
A : Type u_5
B : Type u_6
α : Type u_7
β : Type u_8
γ : Type u_9
δ : Type u_10
M : Type u_11
N : Type u_12
inst✝¹ : Monoid N
inst✝ : SMul M N
h : ∀ (x : M) (y : N), x • 1 * y = x • y
x : M
y z : N
⊢ (x • y) • z = x • y • z
state_after: no goals
tactic: rw [← h, smul_eq_mul, mul_assoc, h, smul_eq_mul]
Theorem: Mathlib.Tactic.Ring.add_overlap_pf_zero
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₂ x : R
e : ℕ
h : a + b = ↑0
⊢ x ^ e * a + x ^ e * b = ↑0
state_after: no goals
tactic: simp [h, ← mul_add]
Theorem: Profinite.NobelingProof.isClosed_C0
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

Proof steps:
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
⊢ IsClosed (C0 C ho)
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
⊢ IsClosed {f | f (term I ho) = false}
tactic: refine hC.inter ?_
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
⊢ IsClosed {f | f (term I ho) = false}
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
h : Continuous fun f => f (term I ho)
⊢ IsClosed {f | f (term I ho) = false}
tactic: have h : Continuous (fun (f : I → Bool) ↦ f (term I ho)) := continuous_apply (term I ho)
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
h : Continuous fun f => f (term I ho)
⊢ IsClosed {f | f (term I ho) = false}
state_after: no goals
tactic: exact IsClosed.preimage h (t := {false}) (isClosed_discrete _)
Theorem: hammingNorm_comp
File: Mathlib/InformationTheory/Hamming.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
β : ι → Type u_3
inst✝⁴ : Fintype ι
inst✝³ : (i : ι) → DecidableEq (β i)
γ : ι → Type u_4
inst✝² : (i : ι) → DecidableEq (γ i)
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → Zero (γ i)
f : (i : ι) → γ i → β i
x : (i : ι) → γ i
hf₁ : ∀ (i : ι), Injective (f i)
hf₂ : ∀ (i : ι), f i 0 = 0
⊢ (hammingNorm fun i => f i (x i)) = hammingNorm x
state_after: no goals
tactic: simpa only [← hammingDist_zero_right, hf₂] using hammingDist_comp f hf₁ (y := fun _ ↦ 0)
Theorem: inv_mul_lt_one_iff_lt
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ a * b⁻¹ < 1 ↔ a < b
state_after: no goals
tactic: rw [← mul_lt_mul_iff_right b, inv_mul_cancel_right, one_mul]
Theorem: MvPolynomial.evalₗ_apply
File: Mathlib/FieldTheory/Finite/Polynomial.lean

Proof steps:
state_before: K : Type u_1
σ : Type u_2
inst✝ : CommSemiring K
p q : MvPolynomial σ K
⊢ (fun p e => (eval e) p) (p + q) = (fun p e => (eval e) p) p + (fun p e => (eval e) p) q
state_after: case h
K : Type u_1
σ : Type u_2
inst✝ : CommSemiring K
p q : MvPolynomial σ K
x : σ → K
⊢ (fun p e => (eval e) p) (p + q) x = ((fun p e => (eval e) p) p + (fun p e => (eval e) p) q) x
tactic: ext x
state_before: case h
K : Type u_1
σ : Type u_2
inst✝ : CommSemiring K
p q : MvPolynomial σ K
x : σ → K
⊢ (fun p e => (eval e) p) (p + q) x = ((fun p e => (eval e) p) p + (fun p e => (eval e) p) q) x
state_after: no goals
tactic: simp
state_before: K : Type u_1
σ : Type u_2
inst✝ : CommSemiring K
a : K
p : MvPolynomial σ K
⊢ { toFun := fun p e => (eval e) p, map_add' := ⋯ }.toFun (a • p) =
    (RingHom.id K) a • { toFun := fun p e => (eval e) p, map_add' := ⋯ }.toFun p
state_after: case h
K : Type u_1
σ : Type u_2
inst✝ : CommSemiring K
a : K
p : MvPolynomial σ K
e : σ → K
⊢ { toFun := fun p e => (eval e) p, map_add' := ⋯ }.toFun (a • p) e =
    ((RingHom.id K) a • { toFun := fun p e => (eval e) p, map_add' := ⋯ }.toFun p) e
tactic: ext e
state_before: case h
K : Type u_1
σ : Type u_2
inst✝ : CommSemiring K
a : K
p : MvPolynomial σ K
e : σ → K
⊢ { toFun := fun p e => (eval e) p, map_add' := ⋯ }.toFun (a • p) e =
    ((RingHom.id K) a • { toFun := fun p e => (eval e) p, map_add' := ⋯ }.toFun p) e
state_after: no goals
tactic: simp
Theorem: MeasureTheory.Measure.univ_pi_Ioc_ae_eq_Icc
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 : ι) → PartialOrder (α i)
inst✝ : ∀ (i : ι), NoAtoms (μ i)
f g : (i : ι) → α i
⊢ (univ.pi fun i => Ioc (f i) (g i)) =ᶠ[ae (Measure.pi μ)] Icc f g
state_after: ι : 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 : ι) → PartialOrder (α i)
inst✝ : ∀ (i : ι), NoAtoms (μ i)
f g : (i : ι) → α i
⊢ (univ.pi fun i => Ioc (f i) (g i)) =ᶠ[ae (Measure.pi μ)] univ.pi fun i => Icc (f i) (g i)
tactic: rw [← pi_univ_Icc]
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 : ι) → PartialOrder (α i)
inst✝ : ∀ (i : ι), NoAtoms (μ i)
f g : (i : ι) → α i
⊢ (univ.pi fun i => Ioc (f i) (g i)) =ᶠ[ae (Measure.pi μ)] univ.pi fun i => Icc (f i) (g i)
state_after: no goals
tactic: exact pi_Ioc_ae_eq_pi_Icc
Theorem: Real.cos_int_mul_two_pi_sub_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: n : ℤ
⊢ cos (↑n * (2 * π) - π) = -1
state_after: no goals
tactic: simpa only [cos_zero] using (cos_periodic.int_mul n).sub_antiperiod_eq cos_antiperiodic
Theorem: Set.preimage_congr
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
g✝ : β → γ
f g : α → β
s : Set β
h : ∀ (x : α), f x = g x
⊢ f ⁻¹' s = g ⁻¹' s
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
g✝ : β → γ
f g : α → β
s : Set β
h : ∀ (x : α), f x = g x
x : α
⊢ x ∈ f ⁻¹' s ↔ x ∈ g ⁻¹' s
tactic: congr with x
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
g✝ : β → γ
f g : α → β
s : Set β
h : ∀ (x : α), f x = g x
x : α
⊢ x ∈ f ⁻¹' s ↔ x ∈ g ⁻¹' s
state_after: no goals
tactic: simp [h]
Theorem: CharTwo.sub_eq_add
File: Mathlib/Algebra/CharP/Two.lean

Proof steps:
state_before: R : Type u_1
ι : Type u_2
inst✝¹ : Ring R
inst✝ : CharP R 2
x y : R
⊢ x - y = x + y
state_after: no goals
tactic: rw [sub_eq_add_neg, neg_eq]
Theorem: WittVector.mapFun.natCast
File: Mathlib/RingTheory/WittVector/Basic.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
S : Type u_2
T : Type u_3
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type u_4
β : Type u_5
f : R →+* S
x y : 𝕎 R
n : ℕ
⊢ mapFun (⇑f) n.unaryCast = ↑n
state_after: no goals
tactic: induction n <;> simp [*, Nat.unaryCast, add, one, zero] <;> rfl