1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Finset.subset_map_symm
File: Mathlib/Data/Finset/Image.lean

tactic: constructor <;> intro h x hx
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : α ↪ β
s : Finset α
t : Finset β
f : α ≃ β
⊢ s ⊆ map f.symm.toEmbedding t ↔ map f.toEmbedding s ⊆ t
state_after: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : α ↪ β
s : Finset α
t : Finset β
f : α ≃ β
h : s ⊆ map f.symm.toEmbedding t
x : β
hx : x ∈ map f.toEmbedding s
⊢ x ∈ t

case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : α ↪ β
s : Finset α
t : Finset β
f : α ≃ β
h : map f.toEmbedding s ⊆ t
x : α
hx : x ∈ s
⊢ x ∈ map f.symm.toEmbedding t

tactic: simp only [mem_map_equiv, Equiv.symm_symm] at hx
state_before: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : α ↪ β
s : Finset α
t : Finset β
f : α ≃ β
h : s ⊆ map f.symm.toEmbedding t
x : β
hx : x ∈ map f.toEmbedding s
⊢ x ∈ t
state_after: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : α ↪ β
s : Finset α
t : Finset β
f : α ≃ β
h : s ⊆ map f.symm.toEmbedding t
x : β
hx : f.symm x ∈ s
⊢ x ∈ t

tactic: simpa using h hx
state_before: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : α ↪ β
s : Finset α
t : Finset β
f : α ≃ β
h : s ⊆ map f.symm.toEmbedding t
x : β
hx : f.symm x ∈ s
⊢ x ∈ t
state_after: no goals

tactic: simp only [mem_map_equiv]
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : α ↪ β
s : Finset α
t : Finset β
f : α ≃ β
h : map f.toEmbedding s ⊆ t
x : α
hx : x ∈ s
⊢ x ∈ map f.symm.toEmbedding t
state_after: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : α ↪ β
s : Finset α
t : Finset β
f : α ≃ β
h : map f.toEmbedding s ⊆ t
x : α
hx : x ∈ s
⊢ f.symm.symm x ∈ t

tactic: exact h (by simp [hx])
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : α ↪ β
s : Finset α
t : Finset β
f : α ≃ β
h : map f.toEmbedding s ⊆ t
x : α
hx : x ∈ s
⊢ f.symm.symm x ∈ t
state_after: no goals

tactic: simp [hx]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : α ↪ β
s : Finset α
t : Finset β
f : α ≃ β
h : map f.toEmbedding s ⊆ t
x : α
hx : x ∈ s
⊢ f.symm.symm x ∈ map f.toEmbedding s
state_after: no goals
Theorem: ContDiffAt.differentiableAt
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

tactic: simpa [hn, differentiableWithinAt_univ] using h.differentiableWithinAt
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : ContDiffAt 𝕜 n f x
hn : 1 ≤ n
⊢ DifferentiableAt 𝕜 f x
state_after: no goals
Theorem: WittVector.wittAdd_zero
File: Mathlib/RingTheory/WittVector/Defs.lean

tactic: apply MvPolynomial.map_injective (Int.castRingHom ℚ) Int.cast_injective
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
⊢ wittAdd p 0 = X (0, 0) + X (1, 0)
state_after: case a
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
⊢ (map (Int.castRingHom ℚ)) (wittAdd p 0) = (map (Int.castRingHom ℚ)) (X (0, 0) + X (1, 0))

tactic: simp only [wittAdd, wittStructureRat, AlgHom.map_add, RingHom.map_add, rename_X,
  xInTermsOfW_zero, map_X, wittPolynomial_zero, bind₁_X_right, map_wittStructureInt]
state_before: case a
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
⊢ (map (Int.castRingHom ℚ)) (wittAdd p 0) = (map (Int.castRingHom ℚ)) (X (0, 0) + X (1, 0))
state_after: no goals
Theorem: Finset.sized_compls
File: Mathlib/Data/Finset/Sups.lean

tactic: simpa using h𝒜.compls
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : DecidableEq α
inst✝² : DecidableEq β
inst✝¹ : BooleanAlgebra α
s s₁ s₂ t t₁ t₂ u v : Finset α
a b c : α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
n : ℕ
hn : n ≤ Fintype.card α
h𝒜 : Set.Sized n ↑𝒜ᶜˢ
⊢ Set.Sized (Fintype.card α - n) ↑𝒜
state_after: no goals

tactic: simpa only [Nat.sub_sub_self hn] using h𝒜.compls
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : DecidableEq α
inst✝² : DecidableEq β
inst✝¹ : BooleanAlgebra α
s s₁ s₂ t t₁ t₂ u v : Finset α
a b c : α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
n : ℕ
hn : n ≤ Fintype.card α
h𝒜 : Set.Sized (Fintype.card α - n) ↑𝒜
⊢ Set.Sized n ↑𝒜ᶜˢ
state_after: no goals
Theorem: Nat.factorial_two_mul_le
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: rw [Nat.two_mul, ← factorial_mul_ascFactorial, Nat.mul_comm]
state_before: n : ℕ
⊢ (2 * n)! ≤ (2 * n) ^ n * n !
state_after: n : ℕ
⊢ (n + 1).ascFactorial n * n ! ≤ (n + n) ^ n * n !

tactic: exact Nat.mul_le_mul_right _ (ascFactorial_le_pow_add _ _)
state_before: n : ℕ
⊢ (n + 1).ascFactorial n * n ! ≤ (n + n) ^ n * n !
state_after: no goals
Theorem: Pell.yn_add
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: injection pellZd_add a1 m n with _ h
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
⊢ yn a1 (m + n) = xn a1 m * yn a1 n + yn a1 m * xn a1 n
state_after: a : ℕ
a1 : 1 < a
m n : ℕ
re_eq✝ : ↑(xn a1 (m + n)) = (pellZd a1 m).re * (pellZd a1 n).re + ↑(Pell.d a1) * (pellZd a1 m).im * (pellZd a1 n).im
h : ↑(yn a1 (m + n)) = (pellZd a1 m).re * (pellZd a1 n).im + (pellZd a1 m).im * (pellZd a1 n).re
⊢ yn a1 (m + n) = xn a1 m * yn a1 n + yn a1 m * xn a1 n

tactic: zify
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
re_eq✝ : ↑(xn a1 (m + n)) = (pellZd a1 m).re * (pellZd a1 n).re + ↑(Pell.d a1) * (pellZd a1 m).im * (pellZd a1 n).im
h : ↑(yn a1 (m + n)) = (pellZd a1 m).re * (pellZd a1 n).im + (pellZd a1 m).im * (pellZd a1 n).re
⊢ yn a1 (m + n) = xn a1 m * yn a1 n + yn a1 m * xn a1 n
state_after: a : ℕ
a1 : 1 < a
m n : ℕ
re_eq✝ : ↑(xn a1 (m + n)) = (pellZd a1 m).re * (pellZd a1 n).re + ↑(Pell.d a1) * (pellZd a1 m).im * (pellZd a1 n).im
h : ↑(yn a1 (m + n)) = (pellZd a1 m).re * (pellZd a1 n).im + (pellZd a1 m).im * (pellZd a1 n).re
⊢ ↑(yn a1 (m + n)) = ↑(xn a1 m) * ↑(yn a1 n) + ↑(yn a1 m) * ↑(xn a1 n)

tactic: rw [h]
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
re_eq✝ : ↑(xn a1 (m + n)) = (pellZd a1 m).re * (pellZd a1 n).re + ↑(Pell.d a1) * (pellZd a1 m).im * (pellZd a1 n).im
h : ↑(yn a1 (m + n)) = (pellZd a1 m).re * (pellZd a1 n).im + (pellZd a1 m).im * (pellZd a1 n).re
⊢ ↑(yn a1 (m + n)) = ↑(xn a1 m) * ↑(yn a1 n) + ↑(yn a1 m) * ↑(xn a1 n)
state_after: a : ℕ
a1 : 1 < a
m n : ℕ
re_eq✝ : ↑(xn a1 (m + n)) = (pellZd a1 m).re * (pellZd a1 n).re + ↑(Pell.d a1) * (pellZd a1 m).im * (pellZd a1 n).im
h : ↑(yn a1 (m + n)) = (pellZd a1 m).re * (pellZd a1 n).im + (pellZd a1 m).im * (pellZd a1 n).re
⊢ (pellZd a1 m).re * (pellZd a1 n).im + (pellZd a1 m).im * (pellZd a1 n).re =
    ↑(xn a1 m) * ↑(yn a1 n) + ↑(yn a1 m) * ↑(xn a1 n)

tactic: simp [pellZd]
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
re_eq✝ : ↑(xn a1 (m + n)) = (pellZd a1 m).re * (pellZd a1 n).re + ↑(Pell.d a1) * (pellZd a1 m).im * (pellZd a1 n).im
h : ↑(yn a1 (m + n)) = (pellZd a1 m).re * (pellZd a1 n).im + (pellZd a1 m).im * (pellZd a1 n).re
⊢ (pellZd a1 m).re * (pellZd a1 n).im + (pellZd a1 m).im * (pellZd a1 n).re =
    ↑(xn a1 m) * ↑(yn a1 n) + ↑(yn a1 m) * ↑(xn a1 n)
state_after: no goals
Theorem: TypeVec.const_iff_true
File: Mathlib/Data/TypeVec.lean

tactic: induction i with
| fz      => rfl
| fs _ ih => erw [TypeVec.const, @ih (drop α) x]
state_before: n : ℕ
α : TypeVec.{u_1} n
i : Fin2 n
x : α i
p : Prop
⊢ ofRepeat (TypeVec.const p α i x) ↔ p
state_after: no goals

tactic: rfl
state_before: case fz
n : ℕ
p : Prop
n✝ : ℕ
α : TypeVec.{u_1} (n✝ + 1)
x : α Fin2.fz
⊢ ofRepeat (TypeVec.const p α Fin2.fz x) ↔ p
state_after: no goals

tactic: erw [TypeVec.const, @ih (drop α) x]
state_before: case fs
n : ℕ
p : Prop
n✝ : ℕ
a✝ : Fin2 n✝
ih : ∀ {α : TypeVec.{u_1} n✝} {x : α a✝}, ofRepeat (TypeVec.const p α a✝ x) ↔ p
α : TypeVec.{u_1} (n✝ + 1)
x : α a✝.fs
⊢ ofRepeat (TypeVec.const p α a✝.fs x) ↔ p
state_after: no goals
Theorem: CHSH_id
File: Mathlib/Algebra/Star/CHSH.lean

tactic: linear_combination
  (2 * B₀ * B₁ + 2) * A₀_inv + (B₀ ^ 2 - 2 * B₀ * B₁ + B₁ ^ 2) * A₁_inv +
      (A₀ ^ 2 + 2 * A₀ * A₁ + 1) * B₀_inv +
    (A₀ ^ 2 - 2 * A₀ * A₁ + 1) * B₁_inv
state_before: R : Type u
inst✝ : CommRing R
A₀ A₁ B₀ B₁ : R
A₀_inv : A₀ ^ 2 = 1
A₁_inv : A₁ ^ 2 = 1
B₀_inv : B₀ ^ 2 = 1
B₁_inv : B₁ ^ 2 = 1
⊢ (2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁) * (2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁) =
    4 * (2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁)
state_after: no goals
Theorem: Mathlib.Meta.NormNum.IsNatPowT.bit1
File: Mathlib/Tactic/NormNum/Pow.lean

tactic: simp [two_mul, pow_add, mul_assoc, ← h1]
state_before: a b : ℕ
c : ℕ
h1 : a.pow b = c
⊢ a.pow (2 * b + 1) = c.mul (c.mul a)
state_after: no goals
Theorem: AlgebraicGeometry.MorphismProperty.topologically_isStableUnderComposition
File: Mathlib/AlgebraicGeometry/Morphisms/Constructors.lean

tactic: simp only [MorphismProperty.topologically, Scheme.comp_coeBase, TopCat.coe_comp]
state_before: P : {α β : Type u} → [inst : TopologicalSpace α] → [inst : TopologicalSpace β] → (α → β) → Prop
hP :
  ∀ {α β γ : Type u} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : TopologicalSpace γ] (f : α → β)
    (g : β → γ), P f → P g → P (g ∘ f)
X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
hf : topologically (fun {α β} [TopologicalSpace α] [TopologicalSpace β] => P) f
hg : topologically (fun {α β} [TopologicalSpace α] [TopologicalSpace β] => P) g
⊢ topologically (fun {α β} [TopologicalSpace α] [TopologicalSpace β] => P) (f ≫ g)
state_after: P : {α β : Type u} → [inst : TopologicalSpace α] → [inst : TopologicalSpace β] → (α → β) → Prop
hP :
  ∀ {α β γ : Type u} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : TopologicalSpace γ] (f : α → β)
    (g : β → γ), P f → P g → P (g ∘ f)
X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
hf : topologically (fun {α β} [TopologicalSpace α] [TopologicalSpace β] => P) f
hg : topologically (fun {α β} [TopologicalSpace α] [TopologicalSpace β] => P) g
⊢ P (⇑g.val.base ∘ ⇑f.val.base)

tactic: exact hP _ _ hf hg
state_before: P : {α β : Type u} → [inst : TopologicalSpace α] → [inst : TopologicalSpace β] → (α → β) → Prop
hP :
  ∀ {α β γ : Type u} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : TopologicalSpace γ] (f : α → β)
    (g : β → γ), P f → P g → P (g ∘ f)
X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
hf : topologically (fun {α β} [TopologicalSpace α] [TopologicalSpace β] => P) f
hg : topologically (fun {α β} [TopologicalSpace α] [TopologicalSpace β] => P) g
⊢ P (⇑g.val.base ∘ ⇑f.val.base)
state_after: no goals
Theorem: MeasureTheory.martingale_const_fun
File: Mathlib/Probability/Martingale/Basic.lean

tactic: refine ⟨fun i => hf.mono <| ℱ.mono bot_le, fun i j _ => ?_⟩
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁵ : Preorder ι
m0 : MeasurableSpace Ω
μ✝ : Measure Ω
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f✝ g : ι → Ω → E
ℱ✝ : Filtration ι m0
inst✝¹ : OrderBot ι
ℱ : Filtration ι m0
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
f : Ω → E
hf : StronglyMeasurable f
hfint : Integrable f μ
⊢ Martingale (fun x => f) ℱ μ
state_after: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁵ : Preorder ι
m0 : MeasurableSpace Ω
μ✝ : Measure Ω
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f✝ g : ι → Ω → E
ℱ✝ : Filtration ι m0
inst✝¹ : OrderBot ι
ℱ : Filtration ι m0
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
f : Ω → E
hf : StronglyMeasurable f
hfint : Integrable f μ
i j : ι
x✝ : i ≤ j
⊢ μ[(fun x => f) j|↑ℱ i] =ᶠ[ae μ] (fun x => f) i

tactic: rw [condexp_of_stronglyMeasurable (ℱ.le _) (hf.mono <| ℱ.mono bot_le) hfint]
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁵ : Preorder ι
m0 : MeasurableSpace Ω
μ✝ : Measure Ω
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f✝ g : ι → Ω → E
ℱ✝ : Filtration ι m0
inst✝¹ : OrderBot ι
ℱ : Filtration ι m0
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
f : Ω → E
hf : StronglyMeasurable f
hfint : Integrable f μ
i j : ι
x✝ : i ≤ j
⊢ μ[(fun x => f) j|↑ℱ i] =ᶠ[ae μ] (fun x => f) i
state_after: no goals
Theorem: WittVector.p_nonzero
File: Mathlib/RingTheory/WittVector/Identities.lean

tactic: intro h
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : Nontrivial R
inst✝ : CharP R p
⊢ ↑p ≠ 0
state_after: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : Nontrivial R
inst✝ : CharP R p
h : ↑p = 0
⊢ False

tactic: simpa only [h, zero_coeff, zero_ne_one] using coeff_p_one p R
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : Nontrivial R
inst✝ : CharP R p
h : ↑p = 0
⊢ False
state_after: no goals
Theorem: isConformalMap_of_subsingleton
File: Mathlib/Analysis/NormedSpace/ConformalLinearMap.lean

tactic: simp [Subsingleton.elim x 0]
state_before: R : Type u_1
M : Type u_2
N : Type u_3
G : Type u_4
M' : Type u_5
inst✝⁹ : NormedField R
inst✝⁸ : SeminormedAddCommGroup M
inst✝⁷ : SeminormedAddCommGroup N
inst✝⁶ : SeminormedAddCommGroup G
inst✝⁵ : NormedSpace R M
inst✝⁴ : NormedSpace R N
inst✝³ : NormedSpace R G
inst✝² : NormedAddCommGroup M'
inst✝¹ : NormedSpace R M'
f : M →L[R] N
g : N →L[R] G
c : R
inst✝ : Subsingleton M
f' : M →L[R] N
x : M
⊢ ‖0 x‖ = ‖x‖
state_after: no goals
Theorem: Polynomial.coeff_hermite_self
File: Mathlib/RingTheory/Polynomial/Hermite/Basic.lean

tactic: induction' n with n ih
state_before: n : ℕ
⊢ (hermite n).coeff n = 1
state_after: case zero

⊢ (hermite 0).coeff 0 = 1

case succ
n : ℕ
ih : (hermite n).coeff n = 1
⊢ (hermite (n + 1)).coeff (n + 1) = 1

tactic: apply coeff_C
state_before: case zero

⊢ (hermite 0).coeff 0 = 1
state_after: no goals

tactic: rw [coeff_hermite_succ_succ, ih, coeff_hermite_of_lt, mul_zero, sub_zero]
state_before: case succ
n : ℕ
ih : (hermite n).coeff n = 1
⊢ (hermite (n + 1)).coeff (n + 1) = 1
state_after: case succ
n : ℕ
ih : (hermite n).coeff n = 1
⊢ n < n + 2

tactic: simp
state_before: case succ
n : ℕ
ih : (hermite n).coeff n = 1
⊢ n < n + 2
state_after: no goals
Theorem: ZFSet.IsTransitive.inter
File: Mathlib/SetTheory/ZFC/Ordinal.lean

tactic: rw [mem_inter] at hz ⊢
state_before: x y z✝ : ZFSet
hx : x.IsTransitive
hy : y.IsTransitive
z : ZFSet
hz : z ∈ x ∩ y
w : ZFSet
hw : w ∈ z
⊢ w ∈ x ∩ y
state_after: x y z✝ : ZFSet
hx : x.IsTransitive
hy : y.IsTransitive
z : ZFSet
hz : z ∈ x ∧ z ∈ y
w : ZFSet
hw : w ∈ z
⊢ w ∈ x ∧ w ∈ y

tactic: exact ⟨hx.mem_trans hw hz.1, hy.mem_trans hw hz.2⟩
state_before: x y z✝ : ZFSet
hx : x.IsTransitive
hy : y.IsTransitive
z : ZFSet
hz : z ∈ x ∧ z ∈ y
w : ZFSet
hw : w ∈ z
⊢ w ∈ x ∧ w ∈ y
state_after: no goals
Theorem: card_commutator_closureCommutatorRepresentatives
File: Mathlib/GroupTheory/Abelianization.lean

tactic: rw [commutator_eq_closure G, ← image_commutatorSet_closureCommutatorRepresentatives, ←
  MonoidHom.map_closure, ← commutator_eq_closure]
state_before: G : Type u
inst✝ : Group G
⊢ Nat.card ↥(_root_.commutator ↥(closureCommutatorRepresentatives G)) = Nat.card ↥(_root_.commutator G)
state_after: G : Type u
inst✝ : Group G
⊢ Nat.card ↥(_root_.commutator ↥(closureCommutatorRepresentatives G)) =
    Nat.card
      ↥(map (closureCommutatorRepresentatives G).subtype (_root_.commutator ↥(closureCommutatorRepresentatives G)))

tactic: exact Nat.card_congr (Equiv.Set.image _ _ (subtype_injective _))
state_before: G : Type u
inst✝ : Group G
⊢ Nat.card ↥(_root_.commutator ↥(closureCommutatorRepresentatives G)) =
    Nat.card
      ↥(map (closureCommutatorRepresentatives G).subtype (_root_.commutator ↥(closureCommutatorRepresentatives G)))
state_after: no goals
Theorem: Function.Surjective.sigma_map
File: Mathlib/Data/Sigma/Basic.lean

tactic: simp only [Surjective, Sigma.forall, h₁.forall]
state_before: α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
f₁ : α₁ → α₂
f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)
h₁ : Surjective f₁
h₂ : ∀ (a : α₁), Surjective (f₂ a)
⊢ Surjective (Sigma.map f₁ f₂)
state_after: α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
f₁ : α₁ → α₂
f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)
h₁ : Surjective f₁
h₂ : ∀ (a : α₁), Surjective (f₂ a)
⊢ ∀ (x : α₁) (b : β₂ (f₁ x)), ∃ a, Sigma.map f₁ f₂ a = ⟨f₁ x, b⟩

tactic: exact fun i ↦ (h₂ _).forall.2 fun x ↦ ⟨⟨i, x⟩, rfl⟩
state_before: α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
f₁ : α₁ → α₂
f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)
h₁ : Surjective f₁
h₂ : ∀ (a : α₁), Surjective (f₂ a)
⊢ ∀ (x : α₁) (b : β₂ (f₁ x)), ∃ a, Sigma.map f₁ f₂ a = ⟨f₁ x, b⟩
state_after: no goals
Theorem: Finpartition.parts_eq_empty_iff
File: Mathlib/Order/Partition/Finpartition.lean

tactic: simp_rw [← P.sup_parts]
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
⊢ P.parts = ∅ ↔ a = ⊥
state_after: α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
⊢ P.parts = ∅ ↔ P.parts.sup id = ⊥

tactic: refine ⟨fun h ↦ ?_, fun h ↦ eq_empty_iff_forall_not_mem.2 fun b hb ↦ P.not_bot_mem ?_⟩
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
⊢ P.parts = ∅ ↔ P.parts.sup id = ⊥
state_after: case refine_1
α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
h : P.parts = ∅
⊢ P.parts.sup id = ⊥

case refine_2
α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
h : P.parts.sup id = ⊥
b : α
hb : b ∈ P.parts
⊢ ⊥ ∈ P.parts

tactic: rw [h]
state_before: case refine_1
α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
h : P.parts = ∅
⊢ P.parts.sup id = ⊥
state_after: case refine_1
α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
h : P.parts = ∅
⊢ ∅.sup id = ⊥

tactic: exact Finset.sup_empty
state_before: case refine_1
α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
h : P.parts = ∅
⊢ ∅.sup id = ⊥
state_after: no goals

tactic: rwa [← le_bot_iff.1 ((le_sup hb).trans h.le)]
state_before: case refine_2
α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
h : P.parts.sup id = ⊥
b : α
hb : b ∈ P.parts
⊢ ⊥ ∈ P.parts
state_after: no goals
Theorem: Encodable.decode₂_encode
File: Mathlib/Logic/Encodable/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
inst✝ : Encodable α
a : α
⊢ decode₂ α (encode a) = some a
state_after: case a
α : Type u_1
β : Type u_2
inst✝ : Encodable α
a a✝ : α
⊢ a✝ ∈ decode₂ α (encode a) ↔ a✝ ∈ some a

tactic: simp [mem_decode₂, eq_comm, decode₂_eq_some]
state_before: case a
α : Type u_1
β : Type u_2
inst✝ : Encodable α
a a✝ : α
⊢ a✝ ∈ decode₂ α (encode a) ↔ a✝ ∈ some a
state_after: no goals
Theorem: Part.Dom.bind
File: Mathlib/Data/Part.lean

tactic: ext b
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
o : Part α
h : o.Dom
f : α → Part β
⊢ o.bind f = f (o.get h)
state_after: case H
α : Type u_1
β : Type u_2
γ : Type u_3
o : Part α
h : o.Dom
f : α → Part β
b : β
⊢ b ∈ o.bind f ↔ b ∈ f (o.get h)

tactic: simp only [Part.mem_bind_iff, exists_prop]
state_before: case H
α : Type u_1
β : Type u_2
γ : Type u_3
o : Part α
h : o.Dom
f : α → Part β
b : β
⊢ b ∈ o.bind f ↔ b ∈ f (o.get h)
state_after: case H
α : Type u_1
β : Type u_2
γ : Type u_3
o : Part α
h : o.Dom
f : α → Part β
b : β
⊢ (∃ a ∈ o, b ∈ f a) ↔ b ∈ f (o.get h)

tactic: refine ⟨?_, fun hb => ⟨o.get h, Part.get_mem _, hb⟩⟩
state_before: case H
α : Type u_1
β : Type u_2
γ : Type u_3
o : Part α
h : o.Dom
f : α → Part β
b : β
⊢ (∃ a ∈ o, b ∈ f a) ↔ b ∈ f (o.get h)
state_after: case H
α : Type u_1
β : Type u_2
γ : Type u_3
o : Part α
h : o.Dom
f : α → Part β
b : β
⊢ (∃ a ∈ o, b ∈ f a) → b ∈ f (o.get h)

tactic: rintro ⟨a, ha, hb⟩
state_before: case H
α : Type u_1
β : Type u_2
γ : Type u_3
o : Part α
h : o.Dom
f : α → Part β
b : β
⊢ (∃ a ∈ o, b ∈ f a) → b ∈ f (o.get h)
state_after: case H.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
o : Part α
h : o.Dom
f : α → Part β
b : β
a : α
ha : a ∈ o
hb : b ∈ f a
⊢ b ∈ f (o.get h)

tactic: rwa [Part.get_eq_of_mem ha]
state_before: case H.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
o : Part α
h : o.Dom
f : α → Part β
b : β
a : α
ha : a ∈ o
hb : b ∈ f a
⊢ b ∈ f (o.get h)
state_after: no goals
Theorem: Lists'.subset_nil
File: Mathlib/SetTheory/Lists.lean

tactic: rw [← of_toList l]
state_before: α : Type u_1
l : Lists' α true
⊢ l ⊆ nil → l = nil
state_after: α : Type u_1
l : Lists' α true
⊢ ofList l.toList ⊆ nil → ofList l.toList = nil

tactic: induction toList l <;> intro h
state_before: α : Type u_1
l : Lists' α true
⊢ ofList l.toList ⊆ nil → ofList l.toList = nil
state_after: case nil
α : Type u_1
l : Lists' α true
h : ofList [] ⊆ nil
⊢ ofList [] = nil

case cons
α : Type u_1
l : Lists' α true
head✝ : Lists α
tail✝ : List (Lists α)
tail_ih✝ : ofList tail✝ ⊆ nil → ofList tail✝ = nil
h : ofList (head✝ :: tail✝) ⊆ nil
⊢ ofList (head✝ :: tail✝) = nil

tactic: rfl
state_before: case nil
α : Type u_1
l : Lists' α true
h : ofList [] ⊆ nil
⊢ ofList [] = nil
state_after: no goals

tactic: rcases cons_subset.1 h with ⟨⟨_, ⟨⟩, _⟩, _⟩
state_before: case cons
α : Type u_1
l : Lists' α true
head✝ : Lists α
tail✝ : List (Lists α)
tail_ih✝ : ofList tail✝ ⊆ nil → ofList tail✝ = nil
h : ofList (head✝ :: tail✝) ⊆ nil
⊢ ofList (head✝ :: tail✝) = nil
state_after: no goals
Theorem: Polynomial.eval₂_eq_sum_range
File: Mathlib/Algebra/Polynomial/Eval.lean

tactic: simp
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f : R →+* S
x : S
⊢ (fun i => eval₂ f x ((monomial i) (p.coeff i))) = fun i => f (p.coeff i) * x ^ i
state_after: no goals
Theorem: MvPowerSeries.map_X
File: Mathlib/RingTheory/MvPowerSeries/Basic.lean

tactic: simp [MvPowerSeries.X]
state_before: σ : Type u_1
R : Type u_2
S : Type u_3
T : Type u_4
inst✝² : Semiring R
inst✝¹ : Semiring S
inst✝ : Semiring T
f : R →+* S
g : S →+* T
s : σ
⊢ (map σ f) (X s) = X s
state_after: no goals
Theorem: AdicCompletion.map_id
File: Mathlib/RingTheory/AdicCompletion/Functoriality.lean

tactic: ext a n
state_before: R : Type u_1
inst✝⁸ : CommRing R
I : Ideal R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
N : Type u_3
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
P : Type u_4
inst✝³ : AddCommGroup P
inst✝² : Module R P
T : Type u_5
inst✝¹ : AddCommGroup T
inst✝ : Module (AdicCompletion I R) T
⊢ map I LinearMap.id = LinearMap.id
state_after: case h.h
R : Type u_1
inst✝⁸ : CommRing R
I : Ideal R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
N : Type u_3
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
P : Type u_4
inst✝³ : AddCommGroup P
inst✝² : Module R P
T : Type u_5
inst✝¹ : AddCommGroup T
inst✝ : Module (AdicCompletion I R) T
a : AdicCauchySequence I M
n : ℕ
⊢ ↑((map I LinearMap.id) ((mk I M) a)) n = ↑(LinearMap.id ((mk I M) a)) n

tactic: simp
state_before: case h.h
R : Type u_1
inst✝⁸ : CommRing R
I : Ideal R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
N : Type u_3
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
P : Type u_4
inst✝³ : AddCommGroup P
inst✝² : Module R P
T : Type u_5
inst✝¹ : AddCommGroup T
inst✝ : Module (AdicCompletion I R) T
a : AdicCauchySequence I M
n : ℕ
⊢ ↑((map I LinearMap.id) ((mk I M) a)) n = ↑(LinearMap.id ((mk I M) a)) n
state_after: no goals