1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: OrderEmbedding.coe_birkhoffFinset
File: Mathlib/Order/Birkhoff.lean

tactic: classical
simp [birkhoffFinset]
rw [OrderIso.coe_toOrderEmbedding, Fintype.coe_finsetOrderIsoSet_symm]
simp
state_before: α : Type u_1
inst✝³ : DistribLattice α
inst✝² : OrderBot α
inst✝¹ : Fintype α
inst✝ : DecidablePred SupIrred
a : α
⊢ ↑(birkhoffFinset a) = birkhoffSet a
state_after: no goals

tactic: simp [birkhoffFinset]
state_before: α : Type u_1
inst✝³ : DistribLattice α
inst✝² : OrderBot α
inst✝¹ : Fintype α
inst✝ : DecidablePred SupIrred
a : α
⊢ ↑(birkhoffFinset a) = birkhoffSet a
state_after: α : Type u_1
inst✝³ : DistribLattice α
inst✝² : OrderBot α
inst✝¹ : Fintype α
inst✝ : DecidablePred SupIrred
a : α
⊢ ↑(Fintype.finsetOrderIsoSet.symm.toOrderEmbedding (birkhoffSet a)) = birkhoffSet a

tactic: rw [OrderIso.coe_toOrderEmbedding, Fintype.coe_finsetOrderIsoSet_symm]
state_before: α : Type u_1
inst✝³ : DistribLattice α
inst✝² : OrderBot α
inst✝¹ : Fintype α
inst✝ : DecidablePred SupIrred
a : α
⊢ ↑(Fintype.finsetOrderIsoSet.symm.toOrderEmbedding (birkhoffSet a)) = birkhoffSet a
state_after: α : Type u_1
inst✝³ : DistribLattice α
inst✝² : OrderBot α
inst✝¹ : Fintype α
inst✝ : DecidablePred SupIrred
a : α
⊢ ↑(Fintype.finsetEquivSet.symm (birkhoffSet a)) = birkhoffSet a

tactic: simp
state_before: α : Type u_1
inst✝³ : DistribLattice α
inst✝² : OrderBot α
inst✝¹ : Fintype α
inst✝ : DecidablePred SupIrred
a : α
⊢ ↑(Fintype.finsetEquivSet.symm (birkhoffSet a)) = birkhoffSet a
state_after: no goals
Theorem: Polynomial.aeval_mem_adjoin_singleton
File: Mathlib/Algebra/Polynomial/AlgebraMap.lean

tactic: simpa only [Algebra.adjoin_singleton_eq_range_aeval] using Set.mem_range_self p
state_before: R : Type u
S : Type v
T : Type w
A : Type z
A' : Type u_1
B : Type u_2
a b : R
n : ℕ
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : CommSemiring A'
inst✝³ : Semiring B
inst✝² : Algebra R A
inst✝¹ : Algebra R A'
inst✝ : Algebra R B
p q : R[X]
x : A
⊢ (aeval x) p ∈ Algebra.adjoin R {x}
state_after: no goals
Theorem: Associated.trans
File: Mathlib/Algebra/Associated.lean

tactic: rw [Units.val_mul, mul_assoc]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : Monoid α
x : α
u v : αˣ
⊢ x * ↑(u * v) = x * ↑u * ↑v
state_after: no goals
Theorem: CategoryTheory.GrothendieckTopology.W_iff_isIso_map_of_adjunction
File: Mathlib/CategoryTheory/Sites/Localization.lean

tactic: rw [W_eq_W_range_sheafToPresheaf_obj]
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
G : (Cᵒᵖ ⥤ A) ⥤ Sheaf J A
adj : G ⊣ sheafToPresheaf J A
P₁ P₂ : Cᵒᵖ ⥤ A
f : P₁ ⟶ P₂
⊢ J.W f ↔ IsIso (G.map f)
state_after: 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
G : (Cᵒᵖ ⥤ A) ⥤ Sheaf J A
adj : G ⊣ sheafToPresheaf J A
P₁ P₂ : Cᵒᵖ ⥤ A
f : P₁ ⟶ P₂
⊢ LeftBousfield.W (fun x => x ∈ Set.range (sheafToPresheaf J A).obj) f ↔ IsIso (G.map f)

tactic: exact LeftBousfield.W_iff_isIso_map adj f
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
G : (Cᵒᵖ ⥤ A) ⥤ Sheaf J A
adj : G ⊣ sheafToPresheaf J A
P₁ P₂ : Cᵒᵖ ⥤ A
f : P₁ ⟶ P₂
⊢ LeftBousfield.W (fun x => x ∈ Set.range (sheafToPresheaf J A).obj) f ↔ IsIso (G.map f)
state_after: no goals
Theorem: MeasureTheory.SimpleFunc.map_preimage
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simp only [coe_range, sep_mem_eq, coe_map, Finset.coe_filter,
  ← mem_preimage, inter_comm, preimage_inter_range, ← Finset.mem_coe]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
f : α →ₛ β
g : β → γ
s : Set γ
⊢ ↑(map g f) ⁻¹' s = ↑f ⁻¹' ↑(Finset.filter (fun b => g b ∈ s) f.range)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
f : α →ₛ β
g : β → γ
s : Set γ
⊢ g ∘ ↑f ⁻¹' s = ↑f ⁻¹' (g ⁻¹' s)

tactic: exact preimage_comp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
f : α →ₛ β
g : β → γ
s : Set γ
⊢ g ∘ ↑f ⁻¹' s = ↑f ⁻¹' (g ⁻¹' s)
state_after: no goals
Theorem: AntitoneOn.mapsTo_uIcc
File: Mathlib/Order/Interval/Set/UnorderedInterval.lean

tactic: rw [uIcc, uIcc, ← hf.map_sup, ← hf.map_inf] <;>
  apply_rules [left_mem_uIcc, right_mem_uIcc, hf.mapsTo_Icc]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Lattice β
f : α → β
s : Set α
a b : α
hf : AntitoneOn f [[a, b]]
⊢ MapsTo f [[a, b]] [[f a, f b]]
state_after: no goals
Theorem: MvPolynomial.isHomogeneous_C
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

tactic: apply isHomogeneous_monomial
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
r : R
⊢ (C r).IsHomogeneous 0
state_after: case hn
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
r : R
⊢ degree 0 = 0

tactic: simp only [degree, Finsupp.zero_apply, Finset.sum_const_zero]
state_before: case hn
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
r : R
⊢ degree 0 = 0
state_after: no goals
Theorem: Equiv.simpleGraph_refl
File: Mathlib/Combinatorics/SimpleGraph/Maps.lean

tactic: ext
state_before: V : Type u_1
W : Type u_2
X : Type u_3
G : SimpleGraph V
G' : SimpleGraph W
u v : V
⊢ (Equiv.refl V).simpleGraph = Equiv.refl (SimpleGraph V)
state_after: case H.Adj.h.h.a
V : Type u_1
W : Type u_2
X : Type u_3
G : SimpleGraph V
G' : SimpleGraph W
u v : V
x✝² : SimpleGraph V
x✝¹ x✝ : V
⊢ ((Equiv.refl V).simpleGraph x✝²).Adj x✝¹ x✝ ↔ ((Equiv.refl (SimpleGraph V)) x✝²).Adj x✝¹ x✝

tactic: rfl
state_before: case H.Adj.h.h.a
V : Type u_1
W : Type u_2
X : Type u_3
G : SimpleGraph V
G' : SimpleGraph W
u v : V
x✝² : SimpleGraph V
x✝¹ x✝ : V
⊢ ((Equiv.refl V).simpleGraph x✝²).Adj x✝¹ x✝ ↔ ((Equiv.refl (SimpleGraph V)) x✝²).Adj x✝¹ x✝
state_after: no goals
Theorem: Int.natAbs_eq_iff_associated
File: Mathlib/Data/Int/Associated.lean

tactic: refine Int.natAbs_eq_natAbs_iff.trans ?_
state_before: a b : ℤ
⊢ a.natAbs = b.natAbs ↔ Associated a b
state_after: a b : ℤ
⊢ a = b ∨ a = -b ↔ Associated a b

tactic: constructor
state_before: a b : ℤ
⊢ a = b ∨ a = -b ↔ Associated a b
state_after: case mp
a b : ℤ
⊢ a = b ∨ a = -b → Associated a b

case mpr
a b : ℤ
⊢ Associated a b → a = b ∨ a = -b

tactic: rintro (rfl | rfl)
state_before: case mp
a b : ℤ
⊢ a = b ∨ a = -b → Associated a b
state_after: case mp.inl
a : ℤ
⊢ Associated a a

case mp.inr
b : ℤ
⊢ Associated (-b) b

tactic: rfl
state_before: case mp.inl
a : ℤ
⊢ Associated a a
state_after: no goals

tactic: exact ⟨-1, by simp⟩
state_before: case mp.inr
b : ℤ
⊢ Associated (-b) b
state_after: no goals

tactic: simp
state_before: b : ℤ
⊢ -b * ↑(-1) = b
state_after: no goals

tactic: rintro ⟨u, rfl⟩
state_before: case mpr
a b : ℤ
⊢ Associated a b → a = b ∨ a = -b
state_after: case mpr.intro
a : ℤ
u : ℤˣ
⊢ a = a * ↑u ∨ a = -(a * ↑u)

tactic: obtain rfl | rfl := Int.units_eq_one_or u
state_before: case mpr.intro
a : ℤ
u : ℤˣ
⊢ a = a * ↑u ∨ a = -(a * ↑u)
state_after: case mpr.intro.inl
a : ℤ
⊢ a = a * ↑1 ∨ a = -(a * ↑1)

case mpr.intro.inr
a : ℤ
⊢ a = a * ↑(-1) ∨ a = -(a * ↑(-1))

tactic: exact Or.inl (by simp)
state_before: case mpr.intro.inl
a : ℤ
⊢ a = a * ↑1 ∨ a = -(a * ↑1)
state_after: no goals

tactic: simp
state_before: a : ℤ
⊢ a = a * ↑1
state_after: no goals

tactic: exact Or.inr (by simp)
state_before: case mpr.intro.inr
a : ℤ
⊢ a = a * ↑(-1) ∨ a = -(a * ↑(-1))
state_after: no goals

tactic: simp
state_before: a : ℤ
⊢ a = -(a * ↑(-1))
state_after: no goals
Theorem: EquicontinuousOn.uniformInducing_uniformOnFun_iff_pi'
File: Mathlib/Topology/UniformSpace/Ascoli.lean

tactic: rw [uniformInducing_iff_uniformSpace, uniformInducing_iff_uniformSpace,
    ← EquicontinuousOn.comap_uniformOnFun_eq 𝔖_compact F_eqcont]
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
α : Type u_4
β : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
F : ι → X → α
G : ι → β → α
inst✝ : UniformSpace ι
𝔖 : Set (Set X)
𝔖_compact : ∀ K ∈ 𝔖, IsCompact K
F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K
⊢ UniformInducing (⇑(UniformOnFun.ofFun 𝔖) ∘ F) ↔ UniformInducing ((⋃₀ 𝔖).restrict ∘ F)
state_after: ι : Type u_1
X : Type u_2
Y : Type u_3
α : Type u_4
β : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
F : ι → X → α
G : ι → β → α
inst✝ : UniformSpace ι
𝔖 : Set (Set X)
𝔖_compact : ∀ K ∈ 𝔖, IsCompact K
F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K
⊢ UniformSpace.comap (⇑(UniformOnFun.ofFun 𝔖) ∘ F) (UniformOnFun.uniformSpace X α 𝔖) = inst✝ ↔
    UniformSpace.comap F (UniformOnFun.uniformSpace X α 𝔖) = inst✝

tactic: rfl
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
α : Type u_4
β : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
F : ι → X → α
G : ι → β → α
inst✝ : UniformSpace ι
𝔖 : Set (Set X)
𝔖_compact : ∀ K ∈ 𝔖, IsCompact K
F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K
⊢ UniformSpace.comap (⇑(UniformOnFun.ofFun 𝔖) ∘ F) (UniformOnFun.uniformSpace X α 𝔖) = inst✝ ↔
    UniformSpace.comap F (UniformOnFun.uniformSpace X α 𝔖) = inst✝
state_after: no goals
Theorem: Real.logb_zero
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: simp [logb]
state_before: b x y : ℝ
⊢ logb b 0 = 0
state_after: no goals
Theorem: Real.rpow_lt_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [le_iff_eq_or_lt] at hx
state_before: x y z : ℝ
n : ℕ
hx : 0 ≤ x
hxy : x < y
hz : 0 < z
⊢ x ^ z < y ^ z
state_after: x y z : ℝ
n : ℕ
hx : 0 = x ∨ 0 < x
hxy : x < y
hz : 0 < z
⊢ x ^ z < y ^ z

tactic: cases' hx with hx hx
state_before: x y z : ℝ
n : ℕ
hx : 0 = x ∨ 0 < x
hxy : x < y
hz : 0 < z
⊢ x ^ z < y ^ z
state_after: case inl
x y z : ℝ
n : ℕ
hxy : x < y
hz : 0 < z
hx : 0 = x
⊢ x ^ z < y ^ z

case inr
x y z : ℝ
n : ℕ
hxy : x < y
hz : 0 < z
hx : 0 < x
⊢ x ^ z < y ^ z

tactic: rw [← hx, zero_rpow (ne_of_gt hz)]
state_before: case inl
x y z : ℝ
n : ℕ
hxy : x < y
hz : 0 < z
hx : 0 = x
⊢ x ^ z < y ^ z
state_after: case inl
x y z : ℝ
n : ℕ
hxy : x < y
hz : 0 < z
hx : 0 = x
⊢ 0 < y ^ z

tactic: exact rpow_pos_of_pos (by rwa [← hx] at hxy) _
state_before: case inl
x y z : ℝ
n : ℕ
hxy : x < y
hz : 0 < z
hx : 0 = x
⊢ 0 < y ^ z
state_after: no goals

tactic: rwa [← hx] at hxy
state_before: x y z : ℝ
n : ℕ
hxy : x < y
hz : 0 < z
hx : 0 = x
⊢ 0 < y
state_after: no goals

tactic: rw [rpow_def_of_pos hx, rpow_def_of_pos (lt_trans hx hxy), exp_lt_exp]
state_before: case inr
x y z : ℝ
n : ℕ
hxy : x < y
hz : 0 < z
hx : 0 < x
⊢ x ^ z < y ^ z
state_after: case inr
x y z : ℝ
n : ℕ
hxy : x < y
hz : 0 < z
hx : 0 < x
⊢ log x * z < log y * z

tactic: exact mul_lt_mul_of_pos_right (log_lt_log hx hxy) hz
state_before: case inr
x y z : ℝ
n : ℕ
hxy : x < y
hz : 0 < z
hx : 0 < x
⊢ log x * z < log y * z
state_after: no goals
Theorem: Function.FactorsThrough.extend_apply
File: Mathlib/Logic/Function/Basic.lean

tactic: simp only [extend_def, dif_pos, exists_apply_eq_apply]
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
g : α → γ
hf : FactorsThrough g f
e' : β → γ
a : α
⊢ extend f g e' (f a) = g a
state_after: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
g : α → γ
hf : FactorsThrough g f
e' : β → γ
a : α
⊢ g (Classical.choose ⋯) = g a

tactic: exact hf (Classical.choose_spec (exists_apply_eq_apply f a))
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
g : α → γ
hf : FactorsThrough g f
e' : β → γ
a : α
⊢ g (Classical.choose ⋯) = g a
state_after: no goals
Theorem: CategoryTheory.SimplicialObject.δ_comp_δ'
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: simp [hj, Fin.not_lt_zero] at H
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : i.castSucc < j
hj : j = 0
⊢ False
state_after: no goals

tactic: dsimp [δ]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : i.castSucc < j
⊢ X.δ j ≫ X.δ i = X.δ i.castSucc ≫ X.δ (j.pred ⋯)
state_after: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : i.castSucc < j
⊢ X.map (SimplexCategory.δ j).op ≫ X.map (SimplexCategory.δ i).op =
    X.map (SimplexCategory.δ i.castSucc).op ≫ X.map (SimplexCategory.δ (j.pred ⋯)).op

tactic: simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_δ' H]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : i.castSucc < j
⊢ X.map (SimplexCategory.δ j).op ≫ X.map (SimplexCategory.δ i).op =
    X.map (SimplexCategory.δ i.castSucc).op ≫ X.map (SimplexCategory.δ (j.pred ⋯)).op
state_after: no goals
Theorem: RingHom.range_top_iff_surjective
File: Mathlib/Algebra/Ring/Subring/Basic.lean

tactic: rw [coe_range, coe_top]
state_before: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
s : Subring R
f : R →+* S
⊢ ↑f.range = ↑⊤ ↔ Set.range ⇑f = Set.univ
state_after: no goals
Theorem: AlgebraicGeometry.Polynomial.isOpen_imageOfDf
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/IsOpenComapC.lean

tactic: rw [imageOfDf, setOf_exists fun i (x : PrimeSpectrum R) => coeff f i ∉ x.asIdeal]
state_before: R : Type u_1
inst✝ : CommRing R
f : R[X]
⊢ IsOpen (imageOfDf f)
state_after: R : Type u_1
inst✝ : CommRing R
f : R[X]
⊢ IsOpen (⋃ i, {x | f.coeff i ∉ x.asIdeal})

tactic: exact isOpen_iUnion fun i => isOpen_basicOpen
state_before: R : Type u_1
inst✝ : CommRing R
f : R[X]
⊢ IsOpen (⋃ i, {x | f.coeff i ∉ x.asIdeal})
state_after: no goals
Theorem: Finset.card_bij'
File: Mathlib/Data/Finset/Card.lean

tactic: refine card_bij i hi (fun a1 h1 a2 h2 eq ↦ ?_) (fun b hb ↦ ⟨_, hj b hb, right_inv b hb⟩)
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t✝ u : Finset α
f : α → β
n : ℕ
t : Finset β
i : (a : α) → a ∈ s → β
j : (a : β) → a ∈ t → α
hi : ∀ (a : α) (ha : a ∈ s), i a ha ∈ t
hj : ∀ (a : β) (ha : a ∈ t), j a ha ∈ s
left_inv : ∀ (a : α) (ha : a ∈ s), j (i a ha) ⋯ = a
right_inv : ∀ (a : β) (ha : a ∈ t), i (j a ha) ⋯ = a
⊢ s.card = t.card
state_after: α : Type u_1
β : Type u_2
R : Type u_3
s t✝ u : Finset α
f : α → β
n : ℕ
t : Finset β
i : (a : α) → a ∈ s → β
j : (a : β) → a ∈ t → α
hi : ∀ (a : α) (ha : a ∈ s), i a ha ∈ t
hj : ∀ (a : β) (ha : a ∈ t), j a ha ∈ s
left_inv : ∀ (a : α) (ha : a ∈ s), j (i a ha) ⋯ = a
right_inv : ∀ (a : β) (ha : a ∈ t), i (j a ha) ⋯ = a
a1 : α
h1 : a1 ∈ s
a2 : α
h2 : a2 ∈ s
eq : i a1 h1 = i a2 h2
⊢ a1 = a2

tactic: rw [← left_inv a1 h1, ← left_inv a2 h2]
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t✝ u : Finset α
f : α → β
n : ℕ
t : Finset β
i : (a : α) → a ∈ s → β
j : (a : β) → a ∈ t → α
hi : ∀ (a : α) (ha : a ∈ s), i a ha ∈ t
hj : ∀ (a : β) (ha : a ∈ t), j a ha ∈ s
left_inv : ∀ (a : α) (ha : a ∈ s), j (i a ha) ⋯ = a
right_inv : ∀ (a : β) (ha : a ∈ t), i (j a ha) ⋯ = a
a1 : α
h1 : a1 ∈ s
a2 : α
h2 : a2 ∈ s
eq : i a1 h1 = i a2 h2
⊢ a1 = a2
state_after: α : Type u_1
β : Type u_2
R : Type u_3
s t✝ u : Finset α
f : α → β
n : ℕ
t : Finset β
i : (a : α) → a ∈ s → β
j : (a : β) → a ∈ t → α
hi : ∀ (a : α) (ha : a ∈ s), i a ha ∈ t
hj : ∀ (a : β) (ha : a ∈ t), j a ha ∈ s
left_inv : ∀ (a : α) (ha : a ∈ s), j (i a ha) ⋯ = a
right_inv : ∀ (a : β) (ha : a ∈ t), i (j a ha) ⋯ = a
a1 : α
h1 : a1 ∈ s
a2 : α
h2 : a2 ∈ s
eq : i a1 h1 = i a2 h2
⊢ j (i a1 h1) ⋯ = j (i a2 h2) ⋯

tactic: simp only [eq]
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t✝ u : Finset α
f : α → β
n : ℕ
t : Finset β
i : (a : α) → a ∈ s → β
j : (a : β) → a ∈ t → α
hi : ∀ (a : α) (ha : a ∈ s), i a ha ∈ t
hj : ∀ (a : β) (ha : a ∈ t), j a ha ∈ s
left_inv : ∀ (a : α) (ha : a ∈ s), j (i a ha) ⋯ = a
right_inv : ∀ (a : β) (ha : a ∈ t), i (j a ha) ⋯ = a
a1 : α
h1 : a1 ∈ s
a2 : α
h2 : a2 ∈ s
eq : i a1 h1 = i a2 h2
⊢ j (i a1 h1) ⋯ = j (i a2 h2) ⋯
state_after: no goals
Theorem: CategoryTheory.Limits.factorThruImageSubobject_comp_self_assoc
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: ext
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
inst✝ : HasImage f
W W' : C
k : W ⟶ W'
k' : W' ⟶ X
h : (imageSubobject f).Factors (k ≫ k' ≫ f)
⊢ (imageSubobject f).factorThru (k ≫ k' ≫ f) h = k ≫ k' ≫ factorThruImageSubobject f
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
inst✝ : HasImage f
W W' : C
k : W ⟶ W'
k' : W' ⟶ X
h : (imageSubobject f).Factors (k ≫ k' ≫ f)
⊢ (imageSubobject f).factorThru (k ≫ k' ≫ f) h ≫ (imageSubobject f).arrow =
    (k ≫ k' ≫ factorThruImageSubobject f) ≫ (imageSubobject f).arrow

tactic: simp
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
inst✝ : HasImage f
W W' : C
k : W ⟶ W'
k' : W' ⟶ X
h : (imageSubobject f).Factors (k ≫ k' ≫ f)
⊢ (imageSubobject f).factorThru (k ≫ k' ≫ f) h ≫ (imageSubobject f).arrow =
    (k ≫ k' ≫ factorThruImageSubobject f) ≫ (imageSubobject f).arrow
state_after: no goals
Theorem: sameRay_or_ne_zero_and_sameRay_neg_iff_not_linearIndependent
File: Mathlib/LinearAlgebra/Ray.lean

tactic: rw [← sameRay_or_sameRay_neg_iff_not_linearIndependent]
state_before: R : Type u_1
inst✝³ : LinearOrderedCommRing R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
x y : M
⊢ SameRay R x y ∨ x ≠ 0 ∧ y ≠ 0 ∧ SameRay R x (-y) ↔ ¬LinearIndependent R ![x, y]
state_after: R : Type u_1
inst✝³ : LinearOrderedCommRing R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
x y : M
⊢ SameRay R x y ∨ x ≠ 0 ∧ y ≠ 0 ∧ SameRay R x (-y) ↔ SameRay R x y ∨ SameRay R x (-y)

tactic: by_cases hx : x = 0
state_before: R : Type u_1
inst✝³ : LinearOrderedCommRing R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
x y : M
⊢ SameRay R x y ∨ x ≠ 0 ∧ y ≠ 0 ∧ SameRay R x (-y) ↔ SameRay R x y ∨ SameRay R x (-y)
state_after: case pos
R : Type u_1
inst✝³ : LinearOrderedCommRing R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
x y : M
hx : x = 0
⊢ SameRay R x y ∨ x ≠ 0 ∧ y ≠ 0 ∧ SameRay R x (-y) ↔ SameRay R x y ∨ SameRay R x (-y)

case neg
R : Type u_1
inst✝³ : LinearOrderedCommRing R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
x y : M
hx : ¬x = 0
⊢ SameRay R x y ∨ x ≠ 0 ∧ y ≠ 0 ∧ SameRay R x (-y) ↔ SameRay R x y ∨ SameRay R x (-y)

tactic: by_cases hy : y = 0 <;> simp [hx, hy]
state_before: case neg
R : Type u_1
inst✝³ : LinearOrderedCommRing R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
x y : M
hx : ¬x = 0
⊢ SameRay R x y ∨ x ≠ 0 ∧ y ≠ 0 ∧ SameRay R x (-y) ↔ SameRay R x y ∨ SameRay R x (-y)
state_after: no goals

tactic: simp [hx]
state_before: case pos
R : Type u_1
inst✝³ : LinearOrderedCommRing R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
x y : M
hx : x = 0
⊢ SameRay R x y ∨ x ≠ 0 ∧ y ≠ 0 ∧ SameRay R x (-y) ↔ SameRay R x y ∨ SameRay R x (-y)
state_after: no goals
Theorem: Fin.lt_iff_le_and_ne
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [← val_ne_iff]
state_before: n m : ℕ
a b c : Fin n
⊢ a < b ↔ a ≤ b ∧ a ≠ b
state_after: n m : ℕ
a b c : Fin n
⊢ a < b ↔ a ≤ b ∧ ↑a ≠ ↑b

tactic: exact Nat.lt_iff_le_and_ne
state_before: n m : ℕ
a b c : Fin n
⊢ a < b ↔ a ≤ b ∧ ↑a ≠ ↑b
state_after: no goals
Theorem: TrivSqZeroExt.fst_exp
File: Mathlib/Analysis/NormedSpace/TrivSqZeroExt.lean

tactic: rw [exp_def, fst_add, fst_inl, fst_inr, add_zero]
state_before: 𝕜 : Type u_1
S : Type u_2
R : Type u_3
M : Type u_4
inst✝¹⁷ : Field 𝕜
inst✝¹⁶ : CharZero 𝕜
inst✝¹⁵ : CommRing R
inst✝¹⁴ : AddCommGroup M
inst✝¹³ : Algebra 𝕜 R
inst✝¹² : Module 𝕜 M
inst✝¹¹ : Module R M
inst✝¹⁰ : Module Rᵐᵒᵖ M
inst✝⁹ : IsCentralScalar R M
inst✝⁸ : IsScalarTower 𝕜 R M
inst✝⁷ : TopologicalSpace R
inst✝⁶ : TopologicalSpace M
inst✝⁵ : TopologicalRing R
inst✝⁴ : TopologicalAddGroup M
inst✝³ : ContinuousSMul R M
inst✝² : ContinuousSMul Rᵐᵒᵖ M
inst✝¹ : T2Space R
inst✝ : T2Space M
x : tsze R M
⊢ (exp 𝕜 x).fst = exp 𝕜 x.fst
state_after: no goals
Theorem: LieIdeal.coe_killingCompl_top
File: Mathlib/Algebra/Lie/TraceForm.lean

tactic: ext x
state_before: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
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
inst✝³ : Module.Free R M
inst✝² : Module.Finite R M
inst✝¹ : Module.Free R L
inst✝ : Module.Finite R L
I : LieIdeal R L
⊢ (lieIdealSubalgebra R L (killingCompl R L ⊤)).toSubmodule = LinearMap.ker (killingForm R L)
state_after: case h
R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
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
inst✝³ : Module.Free R M
inst✝² : Module.Finite R M
inst✝¹ : Module.Free R L
inst✝ : Module.Finite R L
I : LieIdeal R L
x : L
⊢ x ∈ (lieIdealSubalgebra R L (killingCompl R L ⊤)).toSubmodule ↔ x ∈ LinearMap.ker (killingForm R L)

tactic: simp [LinearMap.ext_iff, LinearMap.BilinForm.IsOrtho, LieModule.traceForm_comm R L L x]
state_before: case h
R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
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
inst✝³ : Module.Free R M
inst✝² : Module.Finite R M
inst✝¹ : Module.Free R L
inst✝ : Module.Finite R L
I : LieIdeal R L
x : L
⊢ x ∈ (lieIdealSubalgebra R L (killingCompl R L ⊤)).toSubmodule ↔ x ∈ LinearMap.ker (killingForm R L)
state_after: no goals
Theorem: ValuationSubring.unitGroup_injective
File: Mathlib/RingTheory/Valuation/ValuationSubring.lean

tactic: simpa only [le_antisymm_iff, unitGroup_le_unitGroup] using h
state_before: K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
h : A.unitGroup = B.unitGroup
⊢ A = B
state_after: no goals
Theorem: ZMod.val_one_eq_one_mod
File: Mathlib/Data/ZMod/Basic.lean

tactic: rw [← Nat.cast_one, val_natCast]
state_before: n : ℕ
⊢ val 1 = 1 % n
state_after: no goals
Theorem: CategoryTheory.Functor.map_units_smul
File: Mathlib/CategoryTheory/Linear/LinearFunctor.lean

tactic: apply map_smul
state_before: R : Type u_1
inst✝⁸ : Semiring R
C : Type u_2
D : Type u_3
inst✝⁷ : Category.{u_4, u_2} C
inst✝⁶ : Category.{u_5, u_3} D
inst✝⁵ : Preadditive C
inst✝⁴ : Preadditive D
inst✝³ : CategoryTheory.Linear R C
inst✝² : CategoryTheory.Linear R D
F : C ⥤ D
inst✝¹ : F.Additive
inst✝ : Linear R F
X Y : C
r : Rˣ
f : X ⟶ Y
⊢ F.map (r • f) = r • F.map f
state_after: no goals
Theorem: Matrix.coe_units_inv
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: letI := A.invertible
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B : Matrix n n α
A : (Matrix n n α)ˣ
⊢ ↑A⁻¹ = (↑A)⁻¹
state_after: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B : Matrix n n α
A : (Matrix n n α)ˣ
this : Invertible ↑A := A.invertible
⊢ ↑A⁻¹ = (↑A)⁻¹

tactic: rw [← invOf_eq_nonsing_inv, invOf_units]
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B : Matrix n n α
A : (Matrix n n α)ˣ
this : Invertible ↑A := A.invertible
⊢ ↑A⁻¹ = (↑A)⁻¹
state_after: no goals
Theorem: Stream'.WSeq.join_ret
File: Mathlib/Data/Seq/WSeq.lean

tactic: simpa [ret] using think_equiv _
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
⊢ (ret s).join ~ʷ s
state_after: no goals
Theorem: quadraticChar_one_iff_isSquare
File: Mathlib/NumberTheory/LegendreSymbol/QuadraticChar/Basic.lean

tactic: simp only [quadraticChar_apply, quadraticCharFun, ha, if_false, ite_eq_left_iff,
  (by omega : (-1 : ℤ) ≠ 1), imp_false, not_not]
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
a : F
ha : a ≠ 0
⊢ (quadraticChar F) a = 1 ↔ IsSquare a
state_after: no goals

tactic: omega
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
a : F
ha : a ≠ 0
⊢ -1 ≠ 1
state_after: no goals