1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ChainClosure.isChain
File: Mathlib/Order/Chain.lean

tactic: induction hc with
| succ _ h => exact h.succ
| union hs h =>
  exact fun c₁ ⟨t₁, ht₁, (hc₁ : c₁ ∈ t₁)⟩ c₂ ⟨t₂, ht₂, (hc₂ : c₂ ∈ t₂)⟩ hneq =>
    ((hs _ ht₁).total <| hs _ ht₂).elim (fun ht => h t₂ ht₂ (ht hc₁) hc₂ hneq) fun ht =>
      h t₁ ht₁ hc₁ (ht hc₂) hneq
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
hc : ChainClosure r c
⊢ IsChain r c
state_after: no goals

tactic: exact h.succ
state_before: case succ
α : Type u_1
β : Type u_2
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
s✝ : Set α
a✝ : ChainClosure r s✝
h : IsChain r s✝
⊢ IsChain r (SuccChain r s✝)
state_after: no goals

tactic: exact fun c₁ ⟨t₁, ht₁, (hc₁ : c₁ ∈ t₁)⟩ c₂ ⟨t₂, ht₂, (hc₂ : c₂ ∈ t₂)⟩ hneq =>
  ((hs _ ht₁).total <| hs _ ht₂).elim (fun ht => h t₂ ht₂ (ht hc₁) hc₂ hneq) fun ht =>
    h t₁ ht₁ hc₁ (ht hc₂) hneq
state_before: case union
α : Type u_1
β : Type u_2
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
s✝ : Set (Set α)
hs : ∀ a ∈ s✝, ChainClosure r a
h : ∀ a ∈ s✝, IsChain r a
⊢ IsChain r (⋃₀ s✝)
state_after: no goals
Theorem: Asymptotics.IsBigOWith.sub
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simpa only [sub_eq_add_neg] using h₁.add h₂.neg_left
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
f₁ f₂ : α → E'
g₁ g₂ : α → F'
h₁ : IsBigOWith c₁ l f₁ g
h₂ : IsBigOWith c₂ l f₂ g
⊢ IsBigOWith (c₁ + c₂) l (fun x => f₁ x - f₂ x) g
state_after: no goals
Theorem: MvPolynomial.ker_map
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: ext
state_before: R : Type u
S : Type u_1
σ : Type v
M : Type w
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : R →+* S
⊢ RingHom.ker (map f) = Ideal.map C (RingHom.ker f)
state_after: case h
R : Type u
S : Type u_1
σ : Type v
M : Type w
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : R →+* S
x✝ : MvPolynomial σ R
⊢ x✝ ∈ RingHom.ker (map f) ↔ x✝ ∈ Ideal.map C (RingHom.ker f)

tactic: rw [MvPolynomial.mem_map_C_iff, RingHom.mem_ker, MvPolynomial.ext_iff]
state_before: case h
R : Type u
S : Type u_1
σ : Type v
M : Type w
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : R →+* S
x✝ : MvPolynomial σ R
⊢ x✝ ∈ RingHom.ker (map f) ↔ x✝ ∈ Ideal.map C (RingHom.ker f)
state_after: case h
R : Type u
S : Type u_1
σ : Type v
M : Type w
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : R →+* S
x✝ : MvPolynomial σ R
⊢ (∀ (m : σ →₀ ℕ), coeff m ((map f) x✝) = coeff m 0) ↔ ∀ (m : σ →₀ ℕ), coeff m x✝ ∈ RingHom.ker f

tactic: simp_rw [coeff_map, coeff_zero, RingHom.mem_ker]
state_before: case h
R : Type u
S : Type u_1
σ : Type v
M : Type w
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : R →+* S
x✝ : MvPolynomial σ R
⊢ (∀ (m : σ →₀ ℕ), coeff m ((map f) x✝) = coeff m 0) ↔ ∀ (m : σ →₀ ℕ), coeff m x✝ ∈ RingHom.ker f
state_after: no goals
Theorem: jacobiSym.mul_left
File: Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean

tactic: simp_rw [jacobiSym, List.pmap_eq_map_attach, legendreSym.mul _ _ _]
state_before: a₁ a₂ : ℤ
b : ℕ
⊢ J(a₁ * a₂ | b) = J(a₁ | b) * J(a₂ | b)
state_after: a₁ a₂ : ℤ
b : ℕ
⊢ (List.map (fun x => legendreSym (↑x) a₁ * legendreSym (↑x) a₂) b.factors.attach).prod =
    (List.map (fun x => legendreSym (↑x) a₁) b.factors.attach).prod *
      (List.map (fun x => legendreSym (↑x) a₂) b.factors.attach).prod

tactic: exact List.prod_map_mul (α := ℤ) (l := (factors b).attach)
  (f := fun x ↦ @legendreSym x {out := prime_of_mem_factors x.2} a₁)
  (g := fun x ↦ @legendreSym x {out := prime_of_mem_factors x.2} a₂)
state_before: a₁ a₂ : ℤ
b : ℕ
⊢ (List.map (fun x => legendreSym (↑x) a₁ * legendreSym (↑x) a₂) b.factors.attach).prod =
    (List.map (fun x => legendreSym (↑x) a₁) b.factors.attach).prod *
      (List.map (fun x => legendreSym (↑x) a₂) b.factors.attach).prod
state_after: no goals
Theorem: LieSubmodule.map_incl_top
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: simp
state_before: R : Type u
L : Type v
M : Type w
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
N : LieSubmodule R L M
⊢ map N.incl ⊤ = N
state_after: no goals
Theorem: smul_neg_iff_of_pos_left
File: Mathlib/Algebra/Order/Module/Defs.lean

tactic: simpa only [smul_zero]  using smul_lt_smul_iff_of_pos_left ha (b₂ := (0 : β))
state_before: α : Type u_1
β : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β
inst✝⁶ : Zero α
inst✝⁵ : Zero β
inst✝⁴ : SMulZeroClass α β
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : PosSMulStrictMono α β
inst✝ : PosSMulReflectLT α β
ha : 0 < a
⊢ a • b < 0 ↔ b < 0
state_after: no goals
Theorem: Primrec.list_foldr
File: Mathlib/Computability/Primrec.lean

tactic: simp [List.foldl_reverse]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → List β
g : α → σ
h : α → β × σ → σ
hf : Primrec f
hg : Primrec g
hh : Primrec₂ h
a : α
⊢ List.foldl (fun s b => h (a, s, b).1 ((a, s, b).2.2, (a, s, b).2.1)) (g a) (f a).reverse =
    List.foldr (fun b s => h a (b, s)) (g a) (f a)
state_after: no goals
Theorem: Matrix.forall_iff
File: Mathlib/Data/Matrix/Reflection.lean

tactic: simp only [Forall, FinVec.forall_iff, forall_iff]
state_before: l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
P : Matrix (Fin (m + 1)) (Fin n) α → Prop
⊢ Forall P ↔ ∀ (x : Matrix (Fin (m + 1)) (Fin n) α), P x
state_after: l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
P : Matrix (Fin (m + 1)) (Fin n) α → Prop
⊢ (∀ (x : Fin n → α) (x_1 : Matrix (Fin m) (Fin n) α), P (of (vecCons x x_1))) ↔
    ∀ (x : Matrix (Fin (m + 1)) (Fin n) α), P x

tactic: exact Iff.symm Fin.forall_fin_succ_pi
state_before: l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
P : Matrix (Fin (m + 1)) (Fin n) α → Prop
⊢ (∀ (x : Fin n → α) (x_1 : Matrix (Fin m) (Fin n) α), P (of (vecCons x x_1))) ↔
    ∀ (x : Matrix (Fin (m + 1)) (Fin n) α), P x
state_after: no goals
Theorem: Action.rightUnitor_inv_hom
File: Mathlib/RepresentationTheory/Action/Monoidal.lean

tactic: dsimp
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
X : Action V G
⊢ (ρ_ X).inv.hom = (ρ_ X.V).inv
state_after: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
X : Action V G
⊢ 𝟙 X.V ≫ (ρ_ X.V).inv ≫ (𝟙 X.V ⊗ 𝟙 (𝟙_ V)) = (ρ_ X.V).inv

tactic: simp
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
X : Action V G
⊢ 𝟙 X.V ≫ (ρ_ X.V).inv ≫ (𝟙 X.V ⊗ 𝟙 (𝟙_ V)) = (ρ_ X.V).inv
state_after: no goals
Theorem: Int.cast_pow
File: Mathlib/Algebra/Ring/Int.lean

tactic: induction' m with m ih <;> simp [_root_.pow_succ, *]
state_before: R : Type u_1
inst✝ : Ring R
n : ℤ
m : ℕ
⊢ ↑(n ^ m) = ↑n ^ m
state_after: no goals
Theorem: AlgebraicGeometry.Scheme.Pullback.t'_snd_fst_snd
File: Mathlib/AlgebraicGeometry/Pullbacks.lean

tactic: simp only [t', Category.assoc, pullbackSymmetry_hom_comp_snd_assoc,
  pullbackRightPullbackFstIso_inv_fst_assoc, pullback.lift_fst_assoc, t_fst_snd,
  pullbackRightPullbackFstIso_hom_fst_assoc]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ pullback.snd ≫ pullback.fst ≫ pullback.snd = pullback.fst ≫ pullback.fst ≫ pullback.snd
state_after: no goals
Theorem: CategoryTheory.Adjunction.left_triangle
File: Mathlib/CategoryTheory/Adjunction/Basic.lean

tactic: ext
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
⊢ whiskerRight adj.unit F ≫ whiskerLeft F adj.counit = 𝟙 (𝟭 C ⋙ F)
state_after: case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
x✝ : C
⊢ (whiskerRight adj.unit F ≫ whiskerLeft F adj.counit).app x✝ = (𝟙 (𝟭 C ⋙ F)).app x✝

tactic: dsimp
state_before: case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
x✝ : C
⊢ (whiskerRight adj.unit F ≫ whiskerLeft F adj.counit).app x✝ = (𝟙 (𝟭 C ⋙ F)).app x✝
state_after: case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
x✝ : C
⊢ F.map (adj.unit.app x✝) ≫ adj.counit.app (F.obj x✝) = 𝟙 (F.obj x✝)

tactic: erw [← adj.homEquiv_counit, Equiv.symm_apply_eq, adj.homEquiv_unit]
state_before: case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
x✝ : C
⊢ F.map (adj.unit.app x✝) ≫ adj.counit.app (F.obj x✝) = 𝟙 (F.obj x✝)
state_after: case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
x✝ : C
⊢ adj.unit.app x✝ = adj.unit.app x✝ ≫ G.map (𝟙 (F.obj x✝))

tactic: simp
state_before: case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
x✝ : C
⊢ adj.unit.app x✝ = adj.unit.app x✝ ≫ G.map (𝟙 (F.obj x✝))
state_after: no goals
Theorem: List.foldr_hom
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: induction l <;> simp [*, H]
state_before: β₁ : Type u_1
β₂ : Type u_2
α : Type u_3
f : β₁ → β₂
g₁ : α → β₁ → β₁
g₂ : α → β₂ → β₂
l : List α
init : β₁
H : ∀ (x : α) (y : β₁), g₂ x (f y) = f (g₁ x y)
⊢ foldr g₂ (f init) l = f (foldr g₁ init l)
state_after: no goals
Theorem: Subspace.finrank_add_finrank_dualCoannihilator_eq
File: Mathlib/LinearAlgebra/Dual.lean

tactic: rw [finrank_dualCoannihilator_eq]
state_before: K : Type u
V : Type v
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
W✝ : Subspace K V
inst✝ : FiniteDimensional K V
W : Subspace K (Module.Dual K V)
⊢ finrank K ↥W + finrank K ↥(dualCoannihilator W) = finrank K V
state_after: K : Type u
V : Type v
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
W✝ : Subspace K V
inst✝ : FiniteDimensional K V
W : Subspace K (Module.Dual K V)
⊢ finrank K ↥W + finrank K ↥(dualAnnihilator W) = finrank K V

tactic: let equiv := W.quotEquivAnnihilator
state_before: K : Type u
V : Type v
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
W✝ : Subspace K V
inst✝ : FiniteDimensional K V
W : Subspace K (Module.Dual K V)
⊢ finrank K ↥W + finrank K ↥(dualAnnihilator W) = finrank K V
state_after: K : Type u
V : Type v
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
W✝ : Subspace K V
inst✝ : FiniteDimensional K V
W : Subspace K (Module.Dual K V)
equiv : (Module.Dual K V ⧸ W) ≃ₗ[K] ↥(dualAnnihilator W) := W.quotEquivAnnihilator
⊢ finrank K ↥W + finrank K ↥(dualAnnihilator W) = finrank K V

tactic: have eq := LinearEquiv.finrank_eq (R := K) (M := (Module.Dual K V) ⧸ W)
  (M₂ := { x // x ∈ dualAnnihilator W }) equiv
state_before: K : Type u
V : Type v
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
W✝ : Subspace K V
inst✝ : FiniteDimensional K V
W : Subspace K (Module.Dual K V)
equiv : (Module.Dual K V ⧸ W) ≃ₗ[K] ↥(dualAnnihilator W) := W.quotEquivAnnihilator
⊢ finrank K ↥W + finrank K ↥(dualAnnihilator W) = finrank K V
state_after: K : Type u
V : Type v
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
W✝ : Subspace K V
inst✝ : FiniteDimensional K V
W : Subspace K (Module.Dual K V)
equiv : (Module.Dual K V ⧸ W) ≃ₗ[K] ↥(dualAnnihilator W) := W.quotEquivAnnihilator
eq : finrank K (Module.Dual K V ⧸ W) = finrank K ↥(dualAnnihilator W)
⊢ finrank K ↥W + finrank K ↥(dualAnnihilator W) = finrank K V

tactic: rw [eq.symm, add_comm, Submodule.finrank_quotient_add_finrank, Subspace.dual_finrank_eq]
state_before: K : Type u
V : Type v
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
W✝ : Subspace K V
inst✝ : FiniteDimensional K V
W : Subspace K (Module.Dual K V)
equiv : (Module.Dual K V ⧸ W) ≃ₗ[K] ↥(dualAnnihilator W) := W.quotEquivAnnihilator
eq : finrank K (Module.Dual K V ⧸ W) = finrank K ↥(dualAnnihilator W)
⊢ finrank K ↥W + finrank K ↥(dualAnnihilator W) = finrank K V
state_after: no goals
Theorem: LieModule.Weight.coe_toLinear_ne_zero_iff
File: Mathlib/Algebra/Lie/Weights/Linear.lean

tactic: simp
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
inst✝³ : LieAlgebra.IsNilpotent R L
inst✝² : LinearWeights R L M
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : IsNoetherian R M
χ : Weight R L M
⊢ toLinear R L M χ ≠ 0 ↔ χ.IsNonZero
state_after: no goals
Theorem: Bool.false_eq_true_eq_False
File: Mathlib/Init/Data/Bool/Lemmas.lean

tactic: decide
state_before: ⊢ ¬false = true
state_after: no goals
Theorem: List.forall₂_map_left_iff
File: Mathlib/Data/List/Forall2.lean

tactic: simp only [map, forall₂_nil_left_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
f : γ → α
x✝ : List β
⊢ Forall₂ R (map f []) x✝ ↔ Forall₂ (fun c b => R (f c) b) [] x✝
state_after: no goals

tactic: simp only [map, forall₂_cons_left_iff, forall₂_map_left_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
f : γ → α
a : γ
l : List γ
x✝ : List β
⊢ Forall₂ R (map f (a :: l)) x✝ ↔ Forall₂ (fun c b => R (f c) b) (a :: l) x✝
state_after: no goals
Theorem: List.mem_map_swap
File: Mathlib/Data/List/Basic.lean

tactic: induction' xs with x xs xs_ih
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
x : α
y : β
xs : List (α × β)
⊢ (y, x) ∈ map Prod.swap xs ↔ (x, y) ∈ xs
state_after: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
x : α
y : β
⊢ (y, x) ∈ map Prod.swap [] ↔ (x, y) ∈ []

case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
x✝ : α
y : β
x : α × β
xs : List (α × β)
xs_ih : (y, x✝) ∈ map Prod.swap xs ↔ (x✝, y) ∈ xs
⊢ (y, x✝) ∈ map Prod.swap (x :: xs) ↔ (x✝, y) ∈ x :: xs

tactic: simp only [not_mem_nil, map_nil]
state_before: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
x : α
y : β
⊢ (y, x) ∈ map Prod.swap [] ↔ (x, y) ∈ []
state_after: no goals

tactic: cases' x with a b
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
x✝ : α
y : β
x : α × β
xs : List (α × β)
xs_ih : (y, x✝) ∈ map Prod.swap xs ↔ (x✝, y) ∈ xs
⊢ (y, x✝) ∈ map Prod.swap (x :: xs) ↔ (x✝, y) ∈ x :: xs
state_after: case cons.mk
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
x : α
y : β
xs : List (α × β)
xs_ih : (y, x) ∈ map Prod.swap xs ↔ (x, y) ∈ xs
a : α
b : β
⊢ (y, x) ∈ map Prod.swap ((a, b) :: xs) ↔ (x, y) ∈ (a, b) :: xs

tactic: simp only [mem_cons, Prod.mk.inj_iff, map, Prod.swap_prod_mk, Prod.exists, xs_ih, and_comm]
state_before: case cons.mk
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
x : α
y : β
xs : List (α × β)
xs_ih : (y, x) ∈ map Prod.swap xs ↔ (x, y) ∈ xs
a : α
b : β
⊢ (y, x) ∈ map Prod.swap ((a, b) :: xs) ↔ (x, y) ∈ (a, b) :: xs
state_after: no goals
Theorem: Complex.abs_intCast
File: Mathlib/Data/Complex/Abs.lean

tactic: rw [← ofReal_intCast, abs_ofReal]
state_before: n : ℤ
⊢ abs ↑n = |↑n|
state_after: no goals
Theorem: WithLp.prod_aux_uniformity_eq
File: Mathlib/Analysis/NormedSpace/ProdLp.lean

tactic: have A : UniformInducing (WithLp.equiv p (α × β)) :=
  (prod_antilipschitzWith_equiv_aux p α β).uniformInducing
    (prod_lipschitzWith_equiv_aux p α β).uniformContinuous
state_before: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
hp : Fact (1 ≤ p)
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
⊢ 𝓤 (WithLp p (α × β)) = 𝓤 (α × β)
state_after: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
hp : Fact (1 ≤ p)
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
A : UniformInducing ⇑(WithLp.equiv p (α × β))
⊢ 𝓤 (WithLp p (α × β)) = 𝓤 (α × β)

tactic: have : (fun x : WithLp p (α × β) × WithLp p (α × β) =>
  ((WithLp.equiv p (α × β)) x.fst, (WithLp.equiv p (α × β)) x.snd)) = id := by
  ext i <;> rfl
state_before: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
hp : Fact (1 ≤ p)
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
A : UniformInducing ⇑(WithLp.equiv p (α × β))
⊢ 𝓤 (WithLp p (α × β)) = 𝓤 (α × β)
state_after: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
hp : Fact (1 ≤ p)
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
A : UniformInducing ⇑(WithLp.equiv p (α × β))
this : (fun x => ((WithLp.equiv p (α × β)) x.1, (WithLp.equiv p (α × β)) x.2)) = id
⊢ 𝓤 (WithLp p (α × β)) = 𝓤 (α × β)

tactic: rw [← A.comap_uniformity, this, comap_id]
state_before: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
hp : Fact (1 ≤ p)
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
A : UniformInducing ⇑(WithLp.equiv p (α × β))
this : (fun x => ((WithLp.equiv p (α × β)) x.1, (WithLp.equiv p (α × β)) x.2)) = id
⊢ 𝓤 (WithLp p (α × β)) = 𝓤 (α × β)
state_after: no goals

tactic: ext i <;> rfl
state_before: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
hp : Fact (1 ≤ p)
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
A : UniformInducing ⇑(WithLp.equiv p (α × β))
⊢ (fun x => ((WithLp.equiv p (α × β)) x.1, (WithLp.equiv p (α × β)) x.2)) = id
state_after: no goals
Theorem: sup_eq_maxDefault
File: Mathlib/Order/Lattice.lean

tactic: ext x y
state_before: α : Type u
β : Type v
inst✝² : SemilatticeSup α
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
inst✝ : IsTotal α fun x x_1 => x ≤ x_1
⊢ (fun x x_1 => x ⊔ x_1) = maxDefault
state_after: case h.h
α : Type u
β : Type v
inst✝² : SemilatticeSup α
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
inst✝ : IsTotal α fun x x_1 => x ≤ x_1
x y : α
⊢ x ⊔ y = maxDefault x y

tactic: unfold maxDefault
state_before: case h.h
α : Type u
β : Type v
inst✝² : SemilatticeSup α
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
inst✝ : IsTotal α fun x x_1 => x ≤ x_1
x y : α
⊢ x ⊔ y = maxDefault x y
state_after: case h.h
α : Type u
β : Type v
inst✝² : SemilatticeSup α
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
inst✝ : IsTotal α fun x x_1 => x ≤ x_1
x y : α
⊢ x ⊔ y = if x ≤ y then y else x

tactic: split_ifs with h'
state_before: case h.h
α : Type u
β : Type v
inst✝² : SemilatticeSup α
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
inst✝ : IsTotal α fun x x_1 => x ≤ x_1
x y : α
⊢ x ⊔ y = if x ≤ y then y else x
state_after: case pos
α : Type u
β : Type v
inst✝² : SemilatticeSup α
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
inst✝ : IsTotal α fun x x_1 => x ≤ x_1
x y : α
h' : x ≤ y
⊢ x ⊔ y = y

case neg
α : Type u
β : Type v
inst✝² : SemilatticeSup α
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
inst✝ : IsTotal α fun x x_1 => x ≤ x_1
x y : α
h' : ¬x ≤ y
⊢ x ⊔ y = x
Theorem: MeasureTheory.snormEssSup_piecewise
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

tactic: simp only [snormEssSup, ← ENNReal.essSup_piecewise hs]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
s : Set α
f g : α → E
inst✝ : DecidablePred fun x => x ∈ s
hs : MeasurableSet s
⊢ snormEssSup (s.piecewise f g) μ = max (snormEssSup f (μ.restrict s)) (snormEssSup g (μ.restrict sᶜ))
state_after: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
s : Set α
f g : α → E
inst✝ : DecidablePred fun x => x ∈ s
hs : MeasurableSet s
⊢ essSup (fun x => ↑‖s.piecewise f g x‖₊) μ = essSup (s.piecewise (fun x => ↑‖f x‖₊) fun x => ↑‖g x‖₊) μ

tactic: congr with x
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
s : Set α
f g : α → E
inst✝ : DecidablePred fun x => x ∈ s
hs : MeasurableSet s
⊢ essSup (fun x => ↑‖s.piecewise f g x‖₊) μ = essSup (s.piecewise (fun x => ↑‖f x‖₊) fun x => ↑‖g x‖₊) μ
state_after: case e_f.h
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
s : Set α
f g : α → E
inst✝ : DecidablePred fun x => x ∈ s
hs : MeasurableSet s
x : α
⊢ ↑‖s.piecewise f g x‖₊ = s.piecewise (fun x => ↑‖f x‖₊) (fun x => ↑‖g x‖₊) x

tactic: by_cases hx : x ∈ s <;> simp [hx]
state_before: case e_f.h
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
s : Set α
f g : α → E
inst✝ : DecidablePred fun x => x ∈ s
hs : MeasurableSet s
x : α
⊢ ↑‖s.piecewise f g x‖₊ = s.piecewise (fun x => ↑‖f x‖₊) (fun x => ↑‖g x‖₊) x
state_after: no goals
Theorem: CategoryTheory.ShortComplex.Exact.mono_g_iff
File: Mathlib/Algebra/Homology/ShortComplex/Exact.lean

tactic: constructor
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.71401, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
hS : S.Exact
⊢ Mono S.g ↔ S.f = 0
state_after: case mp
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.71401, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
hS : S.Exact
⊢ Mono S.g → S.f = 0

case mpr
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.71401, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
hS : S.Exact
⊢ S.f = 0 → Mono S.g

tactic: intro
state_before: case mp
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.71401, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
hS : S.Exact
⊢ Mono S.g → S.f = 0
state_after: case mp
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.71401, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
hS : S.Exact
a✝ : Mono S.g
⊢ S.f = 0

tactic: rw [← cancel_mono S.g, zero, zero_comp]
state_before: case mp
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.71401, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
hS : S.Exact
a✝ : Mono S.g
⊢ S.f = 0
state_after: no goals

tactic: exact hS.mono_g
state_before: case mpr
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.71401, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
hS : S.Exact
⊢ S.f = 0 → Mono S.g
state_after: no goals
Theorem: sSup_inf_sSup
File: Mathlib/Order/CompleteBooleanAlgebra.lean

tactic: simp only [sSup_eq_iSup, biSup_inf_biSup]
state_before: α : Type u
β : Type v
ι : Sort w
κ : ι → Sort w'
inst✝ : Frame α
s t : Set α
a b : α
⊢ sSup s ⊓ sSup t = ⨆ p ∈ s ×ˢ t, p.1 ⊓ p.2
state_after: no goals