1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Filter.EventuallyLE.isMaxFilter
File: Mathlib/Order/Filter/Extr.lean

tactic: refine hle.mp (h.mono fun x hf hgf => ?_)
state_before: α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
α : Type u_1
β : Type u_2
inst✝ : Preorder β
f g : α → β
a : α
l : Filter α
hle : g ≤ᶠ[l] f
hfga : f a = g a
h : IsMaxFilter f l a
⊢ IsMaxFilter g l a
state_after: α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
α : Type u_1
β : Type u_2
inst✝ : Preorder β
f g : α → β
a : α
l : Filter α
hle : g ≤ᶠ[l] f
hfga : f a = g a
h : IsMaxFilter f l a
x : α
hf : f x ≤ f a
hgf : g x ≤ f x
⊢ g x ≤ g a

tactic: rw [← hfga]
state_before: α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
α : Type u_1
β : Type u_2
inst✝ : Preorder β
f g : α → β
a : α
l : Filter α
hle : g ≤ᶠ[l] f
hfga : f a = g a
h : IsMaxFilter f l a
x : α
hf : f x ≤ f a
hgf : g x ≤ f x
⊢ g x ≤ g a
state_after: α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
α : Type u_1
β : Type u_2
inst✝ : Preorder β
f g : α → β
a : α
l : Filter α
hle : g ≤ᶠ[l] f
hfga : f a = g a
h : IsMaxFilter f l a
x : α
hf : f x ≤ f a
hgf : g x ≤ f x
⊢ g x ≤ f a

tactic: exact le_trans hgf hf
state_before: α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
α : Type u_1
β : Type u_2
inst✝ : Preorder β
f g : α → β
a : α
l : Filter α
hle : g ≤ᶠ[l] f
hfga : f a = g a
h : IsMaxFilter f l a
x : α
hf : f x ≤ f a
hgf : g x ≤ f x
⊢ g x ≤ f a
state_after: no goals
Theorem: Fin.card_fintypeIoc
File: Mathlib/Order/Interval/Finset/Fin.lean

tactic: rw [← card_Ioc, Fintype.card_ofFinset]
state_before: n : ℕ
a b : Fin n
⊢ Fintype.card ↑(Set.Ioc a b) = ↑b - ↑a
state_after: no goals
Theorem: SimpleGraph.Walk.IsCycle.rotate
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: refine ⟨hc.isCircuit.rotate _, ?_⟩
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w x y : V
inst✝ : DecidableEq V
u v : V
c : G.Walk v v
hc : c.IsCycle
h : u ∈ c.support
⊢ (c.rotate h).IsCycle
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w x y : V
inst✝ : DecidableEq V
u v : V
c : G.Walk v v
hc : c.IsCycle
h : u ∈ c.support
⊢ (c.rotate h).support.tail.Nodup

tactic: rw [List.IsRotated.nodup_iff (support_rotate _ _)]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w x y : V
inst✝ : DecidableEq V
u v : V
c : G.Walk v v
hc : c.IsCycle
h : u ∈ c.support
⊢ (c.rotate h).support.tail.Nodup
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w x y : V
inst✝ : DecidableEq V
u v : V
c : G.Walk v v
hc : c.IsCycle
h : u ∈ c.support
⊢ c.support.tail.Nodup

tactic: exact hc.support_nodup
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w x y : V
inst✝ : DecidableEq V
u v : V
c : G.Walk v v
hc : c.IsCycle
h : u ∈ c.support
⊢ c.support.tail.Nodup
state_after: no goals
Theorem: ite_zero_smul
File: Mathlib/Algebra/SMulWithZero.lean

tactic: rw [ite_smul, zero_smul]
state_before: R : Type u_1
R' : Type u_2
M : Type u_3
M' : Type u_4
inst✝⁶ : MonoidWithZero R
inst✝⁵ : MonoidWithZero R'
inst✝⁴ : Zero M
inst✝³ : MulActionWithZero R M
inst✝² : Zero M'
inst✝¹ : SMul R M'
p : Prop
inst✝ : Decidable p
a : R
b : M
⊢ (if p then a else 0) • b = if p then a • b else 0
state_after: no goals
Theorem: Int.Ico_filter_dvd_eq
File: Mathlib/Data/Int/CardIntervalMod.lean

tactic: ext x
state_before: a b r : ℤ
hr : 0 < r
⊢ filter (fun x => r ∣ x) (Ico a b) = map { toFun := fun x => x * r, inj' := ⋯ } (Ico ⌈↑a / ↑r⌉ ⌈↑b / ↑r⌉)
state_after: case a
a b r : ℤ
hr : 0 < r
x : ℤ
⊢ x ∈ filter (fun x => r ∣ x) (Ico a b) ↔ x ∈ map { toFun := fun x => x * r, inj' := ⋯ } (Ico ⌈↑a / ↑r⌉ ⌈↑b / ↑r⌉)

tactic: simp only [mem_map, mem_filter, mem_Ico, ceil_le, lt_ceil, div_le_iff, lt_div_iff,
  dvd_iff_exists_eq_mul_left, cast_pos.2 hr, ← cast_mul, cast_lt, cast_le]
state_before: case a
a b r : ℤ
hr : 0 < r
x : ℤ
⊢ x ∈ filter (fun x => r ∣ x) (Ico a b) ↔ x ∈ map { toFun := fun x => x * r, inj' := ⋯ } (Ico ⌈↑a / ↑r⌉ ⌈↑b / ↑r⌉)
state_after: case a
a b r : ℤ
hr : 0 < r
x : ℤ
⊢ ((a ≤ x ∧ x < b) ∧ ∃ c, x = c * r) ↔
    ∃ a_1, (a ≤ a_1 * r ∧ a_1 * r < b) ∧ { toFun := fun x => x * r, inj' := ⋯ } a_1 = x

tactic: aesop
state_before: case a
a b r : ℤ
hr : 0 < r
x : ℤ
⊢ ((a ≤ x ∧ x < b) ∧ ∃ c, x = c * r) ↔
    ∃ a_1, (a ≤ a_1 * r ∧ a_1 * r < b) ∧ { toFun := fun x => x * r, inj' := ⋯ } a_1 = x
state_after: no goals
Theorem: comul_eq_diag
File: Mathlib/CategoryTheory/Monoidal/Cartesian/Comon_.lean

tactic: ext
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasTerminal C
inst✝ : HasBinaryProducts C
A : Comon_ C
⊢ A.comul = diag A.X
state_after: case w₁
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasTerminal C
inst✝ : HasBinaryProducts C
A : Comon_ C
⊢ A.comul ≫ prod.fst = diag A.X ≫ prod.fst

case w₂
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasTerminal C
inst✝ : HasBinaryProducts C
A : Comon_ C
⊢ A.comul ≫ prod.snd = diag A.X ≫ prod.snd

tactic: simpa using A.comul_counit =≫ prod.fst
state_before: case w₁
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasTerminal C
inst✝ : HasBinaryProducts C
A : Comon_ C
⊢ A.comul ≫ prod.fst = diag A.X ≫ prod.fst
state_after: no goals

tactic: simpa using A.counit_comul =≫ prod.snd
state_before: case w₂
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasTerminal C
inst✝ : HasBinaryProducts C
A : Comon_ C
⊢ A.comul ≫ prod.snd = diag A.X ≫ prod.snd
state_after: no goals
Theorem: ContinuousMap.mem_idealOfSet_compl_singleton
File: Mathlib/Topology/ContinuousFunction/Ideals.lean

tactic: simp only [mem_idealOfSet, compl_compl, Set.mem_singleton_iff, forall_eq]
state_before: X : Type u_1
R : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : Semiring R
inst✝¹ : TopologicalSpace R
inst✝ : TopologicalSemiring R
x : X
f : C(X, R)
⊢ f ∈ idealOfSet R {x}ᶜ ↔ f x = 0
state_after: no goals
Theorem: CategoryTheory.Sieve.pullback_inter
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: simp [Sieve.ext_iff]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
S✝ R✝ : Sieve X
f : Y ⟶ X
S R : Sieve X
⊢ pullback f (S ⊓ R) = pullback f S ⊓ pullback f R
state_after: no goals
Theorem: Finset.Nat.prod_antidiagonal_swap
File: Mathlib/Algebra/BigOperators/NatAntidiagonal.lean

tactic: conv_lhs => rw [← map_swap_antidiagonal, Finset.prod_map]
state_before: M : Type u_1
N : Type u_2
inst✝¹ : CommMonoid M
inst✝ : AddCommMonoid N
n : ℕ
f : ℕ × ℕ → M
⊢ ∏ p ∈ antidiagonal n, f p.swap = ∏ p ∈ antidiagonal n, f p
state_after: M : Type u_1
N : Type u_2
inst✝¹ : CommMonoid M
inst✝ : AddCommMonoid N
n : ℕ
f : ℕ × ℕ → M
⊢ ∏ x ∈ antidiagonal n, f ({ toFun := Prod.swap, inj' := ⋯ } x).swap = ∏ p ∈ antidiagonal n, f p

tactic: rfl
state_before: M : Type u_1
N : Type u_2
inst✝¹ : CommMonoid M
inst✝ : AddCommMonoid N
n : ℕ
f : ℕ × ℕ → M
⊢ ∏ x ∈ antidiagonal n, f ({ toFun := Prod.swap, inj' := ⋯ } x).swap = ∏ p ∈ antidiagonal n, f p
state_after: no goals
Theorem: uniformGroup_inf
File: Mathlib/Topology/Algebra/UniformGroup.lean

tactic: refine uniformGroup_iInf fun b => ?_
state_before: α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : Group β
u₁ u₂ : UniformSpace β
h₁ : UniformGroup β
h₂ : UniformGroup β
⊢ UniformGroup β
state_after: α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : Group β
u₁ u₂ : UniformSpace β
h₁ : UniformGroup β
h₂ : UniformGroup β
b : Bool
⊢ UniformGroup β

tactic: cases b <;> assumption
state_before: α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : Group β
u₁ u₂ : UniformSpace β
h₁ : UniformGroup β
h₂ : UniformGroup β
b : Bool
⊢ UniformGroup β
state_after: no goals
Theorem: Prod.counit_comp_inr
File: Mathlib/RingTheory/Coalgebra/Basic.lean

tactic: ext
state_before: R : Type u
A : Type v
B : Type w
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : Module R A
inst✝² : Module R B
inst✝¹ : Coalgebra R A
inst✝ : Coalgebra R B
⊢ counit ∘ₗ inr R A B = counit
state_after: case h
R : Type u
A : Type v
B : Type w
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : Module R A
inst✝² : Module R B
inst✝¹ : Coalgebra R A
inst✝ : Coalgebra R B
x✝ : B
⊢ (counit ∘ₗ inr R A B) x✝ = counit x✝

tactic: simp
state_before: case h
R : Type u
A : Type v
B : Type w
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : Module R A
inst✝² : Module R B
inst✝¹ : Coalgebra R A
inst✝ : Coalgebra R B
x✝ : B
⊢ (counit ∘ₗ inr R A B) x✝ = counit x✝
state_after: no goals
Theorem: MeasureTheory.Measure.addHaar_closedBall
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

tactic: rw [addHaar_closedBall' μ x hr, addHaar_closed_unit_ball_eq_addHaar_unit_ball]
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F : Type u_2
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s : Set E
x : E
r : ℝ
hr : 0 ≤ r
⊢ μ (closedBall x r) = ENNReal.ofReal (r ^ finrank ℝ E) * μ (ball 0 1)
state_after: no goals
Theorem: Submodule.IsOrtho.map_iff
File: Mathlib/Analysis/InnerProductSpace/Orthogonal.lean

tactic: have hf : ∀ p : Submodule 𝕜 E, (p.map f).comap f.toLinearIsometry = p :=
  comap_map_eq_of_injective f.injective
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
f : E ≃ₗᵢ[𝕜] F
U V : Submodule 𝕜 E
h : Submodule.map f U ⟂ Submodule.map f V
⊢ U ⟂ V
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
f : E ≃ₗᵢ[𝕜] F
U V : Submodule 𝕜 E
h : Submodule.map f U ⟂ Submodule.map f V
hf : ∀ (p : Submodule 𝕜 E), Submodule.comap f.toLinearIsometry (Submodule.map f p) = p
⊢ U ⟂ V

tactic: simpa only [hf] using h.comap f.toLinearIsometry
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
f : E ≃ₗᵢ[𝕜] F
U V : Submodule 𝕜 E
h : Submodule.map f U ⟂ Submodule.map f V
hf : ∀ (p : Submodule 𝕜 E), Submodule.comap f.toLinearIsometry (Submodule.map f p) = p
⊢ U ⟂ V
state_after: no goals
Theorem: Relation.reflTransGen_reflGen
File: Mathlib/Logic/Relation.lean

tactic: simp only [← transGen_reflGen, reflGen_eq_self reflexive_reflGen]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
⊢ ReflTransGen (ReflGen r) = ReflTransGen r
state_after: no goals
Theorem: map_nonneg
File: Mathlib/Algebra/Order/Hom/Monoid.lean

tactic: rw [← map_zero f]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁶ : FunLike F α β
inst✝⁵ : Preorder α
inst✝⁴ : Zero α
inst✝³ : Preorder β
inst✝² : Zero β
inst✝¹ : OrderHomClass F α β
inst✝ : ZeroHomClass F α β
f : F
a : α
ha : 0 ≤ a
⊢ 0 ≤ f a
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁶ : FunLike F α β
inst✝⁵ : Preorder α
inst✝⁴ : Zero α
inst✝³ : Preorder β
inst✝² : Zero β
inst✝¹ : OrderHomClass F α β
inst✝ : ZeroHomClass F α β
f : F
a : α
ha : 0 ≤ a
⊢ f 0 ≤ f a

tactic: exact OrderHomClass.mono _ ha
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁶ : FunLike F α β
inst✝⁵ : Preorder α
inst✝⁴ : Zero α
inst✝³ : Preorder β
inst✝² : Zero β
inst✝¹ : OrderHomClass F α β
inst✝ : ZeroHomClass F α β
f : F
a : α
ha : 0 ≤ a
⊢ f 0 ≤ f a
state_after: no goals
Theorem: TopologicalSpace.isSeparable_closure
File: Mathlib/Topology/Bases.lean

tactic: simp only [IsSeparable, isClosed_closure.closure_subset_iff]
state_before: α : Type u
β : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s : Set α
⊢ IsSeparable (closure s) ↔ IsSeparable s
state_after: no goals
Theorem: star_nonpos_iff
File: Mathlib/Algebra/Star/Order.lean

tactic: simpa using star_le_star_iff (x := x) (y := 0)
state_before: R : Type u
inst✝³ : NonUnitalSemiring R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
x : R
⊢ star x ≤ 0 ↔ x ≤ 0
state_after: no goals
Theorem: Filter.tendsto_mul_const_atTop_of_pos
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simpa only [mul_comm] using tendsto_const_mul_atTop_of_pos hr
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrderedSemifield α
l : Filter β
f : β → α
r c : α
n : ℕ
hr : 0 < r
⊢ Tendsto (fun x => f x * r) l atTop ↔ Tendsto f l atTop
state_after: no goals
Theorem: Set.Finite.closure_biUnion
File: Mathlib/Topology/Basic.lean

tactic: simp [closure_eq_compl_interior_compl, hs.interior_biInter]
state_before: X : Type u
Y : Type v
ι✝ : Sort w
α : Type u_1
β : Type u_2
x : X
s✝ s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
ι : Type u_3
s : Set ι
hs : s.Finite
f : ι → Set X
⊢ closure (⋃ i ∈ s, f i) = ⋃ i ∈ s, closure (f i)
state_after: no goals
Theorem: CategoryTheory.SimplicialObject.Augmented.w₀
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: convert congr_app f.w (op (SimplexCategory.mk 0))
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ : SimplicialObject C
X Y : Augmented C
f : X ⟶ Y
⊢ (drop.map f).app { unop := [0] } ≫ Y.hom.app { unop := [0] } = X.hom.app { unop := [0] } ≫ point.map f
state_after: no goals
Theorem: Finset.cast_card_union
File: Mathlib/Data/Finset/Card.lean

tactic: rw [eq_sub_iff_add_eq, ← cast_add, card_union_add_card_inter, cast_add]
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
inst✝¹ : DecidableEq α
inst✝ : AddGroupWithOne R
⊢ ↑(s ∪ t).card = ↑s.card + ↑t.card - ↑(s ∩ t).card
state_after: no goals
Theorem: Finset.id_traverse
File: Mathlib/Data/Finset/Functor.lean

tactic: rw [traverse, Multiset.id_traverse]
state_before: α β γ : Type u
F G : Type u → Type u
inst✝⁴ : Applicative F
inst✝³ : Applicative G
inst✝² : CommApplicative F
inst✝¹ : CommApplicative G
inst✝ : DecidableEq α
s : Finset α
⊢ traverse pure s = s
state_after: α β γ : Type u
F G : Type u → Type u
inst✝⁴ : Applicative F
inst✝³ : Applicative G
inst✝² : CommApplicative F
inst✝¹ : CommApplicative G
inst✝ : DecidableEq α
s : Finset α
⊢ Multiset.toFinset <$> s.val = s

tactic: exact s.val_toFinset
state_before: α β γ : Type u
F G : Type u → Type u
inst✝⁴ : Applicative F
inst✝³ : Applicative G
inst✝² : CommApplicative F
inst✝¹ : CommApplicative G
inst✝ : DecidableEq α
s : Finset α
⊢ Multiset.toFinset <$> s.val = s
state_after: no goals
Theorem: BoundedLatticeHomClass.toBiheytingHomClass
File: Mathlib/Order/Heyting/Hom.lean

tactic: rw [himp_eq, himp_eq, map_sup, (isCompl_compl.map _).compl_eq]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : FunLike F α β
inst✝² : BooleanAlgebra α
inst✝¹ : BooleanAlgebra β
inst✝ : BoundedLatticeHomClass F α β
f : F
a b : α
⊢ f (a ⇨ b) = f a ⇨ f b
state_after: no goals

tactic: rw [sdiff_eq, sdiff_eq, map_inf, (isCompl_compl.map _).compl_eq]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : FunLike F α β
inst✝² : BooleanAlgebra α
inst✝¹ : BooleanAlgebra β
inst✝ : BoundedLatticeHomClass F α β
f : F
a b : α
⊢ f (a \ b) = f a \ f b
state_after: no goals
Theorem: LinearMap.inl_map_mul
File: Mathlib/LinearAlgebra/Prod.lean

tactic: simp
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
S : Type u_3
inst✝¹⁷ : Semiring R
inst✝¹⁶ : Semiring S
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : AddCommMonoid M₂
inst✝¹³ : AddCommMonoid M₃
inst✝¹² : AddCommMonoid M₄
inst✝¹¹ : AddCommMonoid M₅
inst✝¹⁰ : AddCommMonoid M₆
inst✝⁹ : Module R M
inst✝⁸ : Module R M₂
inst✝⁷ : Module R M₃
inst✝⁶ : Module R M₄
inst✝⁵ : Module R M₅
inst✝⁴ : Module R M₆
f : M →ₗ[R] M₂
A : Type u_4
inst✝³ : NonUnitalNonAssocSemiring A
inst✝² : Module R A
B : Type u_5
inst✝¹ : NonUnitalNonAssocSemiring B
inst✝ : Module R B
a₁ a₂ : A
⊢ ((inl R A B) (a₁ * a₂)).2 = ((inl R A B) a₁ * (inl R A B) a₂).2
state_after: no goals
Theorem: List.ext_get?_iff'
File: Mathlib/Data/List/Basic.lean

tactic: rintro rfl _ _
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ l₁ l₂ : List α
⊢ l₁ = l₂ → ∀ (n : ℕ), n < max l₁.length l₂.length → l₁.get? n = l₂.get? n
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂ l₁ : List α
n✝ : ℕ
a✝ : n✝ < max l₁.length l₁.length
⊢ l₁.get? n✝ = l₁.get? n✝

tactic: rfl
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂ l₁ : List α
n✝ : ℕ
a✝ : n✝ < max l₁.length l₁.length
⊢ l₁.get? n✝ = l₁.get? n✝
state_after: no goals
Theorem: Fintype.card_subtype_or_disjoint
File: Mathlib/Data/Fintype/Sum.lean

tactic: classical
  convert Fintype.card_congr (subtypeOrEquiv p q h)
  simp
state_before: α : Type u_1
β : Type u_2
p q : α → Prop
h : Disjoint p q
inst✝² : Fintype { x // p x }
inst✝¹ : Fintype { x // q x }
inst✝ : Fintype { x // p x ∨ q x }
⊢ card { x // p x ∨ q x } = card { x // p x } + card { x // q x }
state_after: no goals

tactic: convert Fintype.card_congr (subtypeOrEquiv p q h)
state_before: α : Type u_1
β : Type u_2
p q : α → Prop
h : Disjoint p q
inst✝² : Fintype { x // p x }
inst✝¹ : Fintype { x // q x }
inst✝ : Fintype { x // p x ∨ q x }
⊢ card { x // p x ∨ q x } = card { x // p x } + card { x // q x }
state_after: case h.e'_3
α : Type u_1
β : Type u_2
p q : α → Prop
h : Disjoint p q
inst✝² : Fintype { x // p x }
inst✝¹ : Fintype { x // q x }
inst✝ : Fintype { x // p x ∨ q x }
⊢ card { x // p x } + card { x // q x } = card ({ x // p x } ⊕ { x // q x })

tactic: simp
state_before: case h.e'_3
α : Type u_1
β : Type u_2
p q : α → Prop
h : Disjoint p q
inst✝² : Fintype { x // p x }
inst✝¹ : Fintype { x // q x }
inst✝ : Fintype { x // p x ∨ q x }
⊢ card { x // p x } + card { x // q x } = card ({ x // p x } ⊕ { x // q x })
state_after: no goals
Theorem: FractionalIdeal.coe_mul
File: Mathlib/RingTheory/FractionalIdeal/Basic.lean

tactic: simp only [mul_def, coe_mk]
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I J : FractionalIdeal S P
⊢ ↑(I * J) = ↑I * ↑J
state_after: no goals
Theorem: exists_abs_lt
File: Mathlib/Algebra/Order/Ring/Abs.lean

tactic: simp
state_before: α✝ : Type u_1
inst✝¹ : LinearOrderedRing α✝
n : ℕ
a✝ b c : α✝
α : Type u_2
inst✝ : LinearOrderedRing α
a : α
⊢ 1 ≤ |a| + 1
state_after: no goals
Theorem: RestrictGenTopology.isClosed_iff
File: Mathlib/Topology/RestrictGenTopology.lean

tactic: simp only [← isOpen_compl_iff, hS.isOpen_iff, preimage_compl]
state_before: X : Type u_1
inst✝ : TopologicalSpace X
S : Set (Set X)
t : Set X
x : X
hS : RestrictGenTopology S
⊢ IsClosed t ↔ ∀ s ∈ S, IsClosed (Subtype.val ⁻¹' t)
state_after: no goals
Theorem: CategoryTheory.Presheaf.FamilyOfElementsOnObjects.IsCompatible.familyOfElements_apply
File: Mathlib/CategoryTheory/Sites/CoversTop.lean

tactic: apply hx
state_before: C : Type u
inst✝¹ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝ : Category.{v', u'} A
F : Cᵒᵖ ⥤ Type w
I : Type u_1
Y : I → C
x : FamilyOfElementsOnObjects F Y
hx : x.IsCompatible
X Z : C
f : Z ⟶ X
i : I
φ : Z ⟶ Y i
⊢ x.familyOfElements X f ⋯ = F.map φ.op (x i)
state_after: no goals
Theorem: NonUnitalAlgebra.mem_bot
File: Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean

tactic: rw [NonUnitalSubsemiring.closure_empty, NonUnitalSubsemiring.coe_bot,
  Submodule.span_zero_singleton, Submodule.mem_bot]
state_before: F : Type u_1
R : Type u
A : Type v
B : Type w
inst✝¹⁰ : CommSemiring R
inst✝⁹ : NonUnitalNonAssocSemiring A
inst✝⁸ : Module R A
inst✝⁷ : IsScalarTower R A A
inst✝⁶ : SMulCommClass R A A
inst✝⁵ : NonUnitalNonAssocSemiring B
inst✝⁴ : Module R B
inst✝³ : IsScalarTower R B B
inst✝² : SMulCommClass R B B
inst✝¹ : FunLike F A B
inst✝ : NonUnitalAlgHomClass F R A B
x : A
⊢ x ∈ Submodule.span R ↑(NonUnitalSubsemiring.closure ∅) ↔ x = 0
state_after: no goals
Theorem: midpoint_self_neg
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

tactic: rw [midpoint_eq_smul_add, add_neg_self, smul_zero]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x✝ y z : P
x : V
⊢ midpoint R x (-x) = 0
state_after: no goals
Theorem: IsMulFreimanHom.mul_eq_mul
File: Mathlib/Combinatorics/Additive/FreimanHom.lean

tactic: simp_rw [← prod_pair] at h ⊢
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
A A₁ A₂ : Set α
B B₁ B₂ : Set β
C : Set γ
f f₁ f₂ : α → β
g : β → γ
m n : ℕ
hf : IsMulFreimanHom 2 A B f
a b c d : α
ha : a ∈ A
hb : b ∈ A
hc : c ∈ A
hd : d ∈ A
h : a * b = c * d
⊢ f a * f b = f c * f d
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
A A₁ A₂ : Set α
B B₁ B₂ : Set β
C : Set γ
f f₁ f₂ : α → β
g : β → γ
m n : ℕ
hf : IsMulFreimanHom 2 A B f
a b c d : α
ha : a ∈ A
hb : b ∈ A
hc : c ∈ A
hd : d ∈ A
h : {a, b}.prod = {c, d}.prod
⊢ {f a, f b}.prod = {f c, f d}.prod

tactic: refine hf.map_prod_eq_map_prod ?_ ?_ (card_pair _ _) (card_pair _ _) h <;> simp [ha, hb, hc, hd]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
A A₁ A₂ : Set α
B B₁ B₂ : Set β
C : Set γ
f f₁ f₂ : α → β
g : β → γ
m n : ℕ
hf : IsMulFreimanHom 2 A B f
a b c d : α
ha : a ∈ A
hb : b ∈ A
hc : c ∈ A
hd : d ∈ A
h : {a, b}.prod = {c, d}.prod
⊢ {f a, f b}.prod = {f c, f d}.prod
state_after: no goals
Theorem: absorbs_iff_eventually_cobounded_mapsTo
File: Mathlib/Topology/Bornology/Absorbs.lean

tactic: rw [← preimage_smul_inv₀ hc]
state_before: G₀ : Type u_1
α : Type u_2
inst✝² : GroupWithZero G₀
inst✝¹ : Bornology G₀
inst✝ : MulAction G₀ α
s t u : Set α
S : Set (Set α)
c : G₀
hc : c ≠ 0
⊢ t ⊆ c • s ↔ MapsTo (fun x => c⁻¹ • x) t s
state_after: G₀ : Type u_1
α : Type u_2
inst✝² : GroupWithZero G₀
inst✝¹ : Bornology G₀
inst✝ : MulAction G₀ α
s t u : Set α
S : Set (Set α)
c : G₀
hc : c ≠ 0
⊢ t ⊆ (fun x => c⁻¹ • x) ⁻¹' s ↔ MapsTo (fun x => c⁻¹ • x) t s

tactic: rfl
state_before: G₀ : Type u_1
α : Type u_2
inst✝² : GroupWithZero G₀
inst✝¹ : Bornology G₀
inst✝ : MulAction G₀ α
s t u : Set α
S : Set (Set α)
c : G₀
hc : c ≠ 0
⊢ t ⊆ (fun x => c⁻¹ • x) ⁻¹' s ↔ MapsTo (fun x => c⁻¹ • x) t s
state_after: no goals
Theorem: CategoryTheory.SingleFunctors.shiftIso_add_inv_app
File: Mathlib/CategoryTheory/Shift/SingleFunctors.lean

tactic: rw [add_assoc, ha', ha'']
state_before: C : Type u_1
D : Type u_2
E : Type u_3
E' : Type u_4
inst✝⁵ : Category.{?u.9199, u_1} C
inst✝⁴ : Category.{?u.9203, u_2} D
inst✝³ : Category.{?u.9207, u_3} E
A : Type u_5
inst✝² : AddMonoid A
inst✝¹ : HasShift D A
inst✝ : HasShift E A
F G H : SingleFunctors C D A
n m a a' a'' : A
ha' : n + a = a'
ha'' : m + a' = a''
X : C
⊢ m + n + a = a''
state_after: no goals

tactic: simp [F.shiftIso_add n m a a' a'' ha' ha'']
state_before: C : Type u_1
D : Type u_2
E : Type u_3
E' : Type u_4
inst✝⁵ : Category.{u_7, u_1} C
inst✝⁴ : Category.{u_6, u_2} D
inst✝³ : Category.{?u.9207, u_3} E
A : Type u_5
inst✝² : AddMonoid A
inst✝¹ : HasShift D A
inst✝ : HasShift E A
F G H : SingleFunctors C D A
n m a a' a'' : A
ha' : n + a = a'
ha'' : m + a' = a''
X : C
⊢ (F.shiftIso (m + n) a a'' ⋯).inv.app X =
    (F.shiftIso n a a' ha').inv.app X ≫
      (shiftFunctor D n).map ((F.shiftIso m a' a'' ha'').inv.app X) ≫
        (shiftFunctorAdd D m n).inv.app ((F.functor a'').obj X)
state_after: no goals
Theorem: Finset.not_mem_sdiff_of_mem_right
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_sdiff, h, not_true, not_false_iff, and_false_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
h : a ∈ t
⊢ a ∉ s \ t
state_after: no goals