1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Subgroup.bot_prod_bot
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

tactic: simp [coe_prod, Prod.one_eq_mk]
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
H K : Subgroup G
k : Set G
N : Type u_5
inst✝¹ : Group N
P : Type u_6
inst✝ : Group P
⊢ ↑(⊥.prod ⊥) = ↑⊥
state_after: no goals
Theorem: IsRightRegular.mul_right_eq_zero_iff
File: Mathlib/Algebra/Regular/Basic.lean

tactic: nth_rw 1 [← zero_mul b]
state_before: R : Type u_1
inst✝ : MulZeroClass R
a b : R
hb : IsRightRegular b
⊢ a * b = 0 ↔ a = 0
state_after: R : Type u_1
inst✝ : MulZeroClass R
a b : R
hb : IsRightRegular b
⊢ a * b = 0 * b ↔ a = 0

tactic: exact ⟨fun h ↦ hb h, fun ha ↦ by rw [ha]⟩
state_before: R : Type u_1
inst✝ : MulZeroClass R
a b : R
hb : IsRightRegular b
⊢ a * b = 0 * b ↔ a = 0
state_after: no goals

tactic: rw [ha]
state_before: R : Type u_1
inst✝ : MulZeroClass R
a b : R
hb : IsRightRegular b
ha : a = 0
⊢ a * b = 0 * b
state_after: no goals
Theorem: Filter.disjoint_principal_principal
File: Mathlib/Order/Filter/Bases.lean

tactic: rw [← subset_compl_iff_disjoint_left, disjoint_principal_left, mem_principal]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s✝ : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
s t : Set α
⊢ Disjoint (𝓟 s) (𝓟 t) ↔ Disjoint s t
state_after: no goals
Theorem: Complex.closure_setOf_lt_re
File: Mathlib/Analysis/Complex/ReImTopology.lean

tactic: simpa only [closure_Ioi] using closure_preimage_re (Ioi a)
state_before: a : ℝ
⊢ closure {z | a < z.re} = {z | a ≤ z.re}
state_after: no goals
Theorem: Nat.WithBot.one_le_iff_zero_lt
File: Mathlib/Data/Nat/WithBot.lean

tactic: refine ⟨zero_lt_one.trans_le, fun h => ?_⟩
state_before: x : WithBot ℕ
⊢ 1 ≤ x ↔ 0 < x
state_after: x : WithBot ℕ
h : 0 < x
⊢ 1 ≤ x

tactic: cases x
state_before: x : WithBot ℕ
h : 0 < x
⊢ 1 ≤ x
state_after: case bot
h : 0 < ⊥
⊢ 1 ≤ ⊥

case coe
a✝ : ℕ
h : 0 < ↑a✝
⊢ 1 ≤ ↑a✝

tactic: exact (not_lt_bot h).elim
state_before: case bot
h : 0 < ⊥
⊢ 1 ≤ ⊥
state_after: no goals

tactic: rwa [← WithBot.coe_zero, WithBot.coe_lt_coe, ← Nat.add_one_le_iff, zero_add,
  ← WithBot.coe_le_coe, WithBot.coe_one] at h
state_before: case coe
a✝ : ℕ
h : 0 < ↑a✝
⊢ 1 ≤ ↑a✝
state_after: no goals
Theorem: AkraBazziRecurrence.eventually_one_sub_smoothingFn_gt_const_real
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

tactic: have h₁ : Tendsto (fun x => 1 - ε x) atTop (𝓝 1) := by
  rw [← isEquivalent_const_iff_tendsto one_ne_zero]
  exact isEquivalent_one_sub_smoothingFn_one
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
c : ℝ
hc : c < 1
⊢ ∀ᶠ (x : ℝ) in atTop, c < 1 - ε x
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
c : ℝ
hc : c < 1
h₁ : Tendsto (fun x => 1 - ε x) atTop (𝓝 1)
⊢ ∀ᶠ (x : ℝ) in atTop, c < 1 - ε x

tactic: rw [tendsto_order] at h₁
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
c : ℝ
hc : c < 1
h₁ : Tendsto (fun x => 1 - ε x) atTop (𝓝 1)
⊢ ∀ᶠ (x : ℝ) in atTop, c < 1 - ε x
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
c : ℝ
hc : c < 1
h₁ : (∀ a' < 1, ∀ᶠ (b : ℝ) in atTop, a' < 1 - ε b) ∧ ∀ a' > 1, ∀ᶠ (b : ℝ) in atTop, 1 - ε b < a'
⊢ ∀ᶠ (x : ℝ) in atTop, c < 1 - ε x

tactic: exact h₁.1 c hc
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
c : ℝ
hc : c < 1
h₁ : (∀ a' < 1, ∀ᶠ (b : ℝ) in atTop, a' < 1 - ε b) ∧ ∀ a' > 1, ∀ᶠ (b : ℝ) in atTop, 1 - ε b < a'
⊢ ∀ᶠ (x : ℝ) in atTop, c < 1 - ε x
state_after: no goals

tactic: rw [← isEquivalent_const_iff_tendsto one_ne_zero]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
c : ℝ
hc : c < 1
⊢ Tendsto (fun x => 1 - ε x) atTop (𝓝 1)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
c : ℝ
hc : c < 1
⊢ (fun x => 1 - ε x) ~[atTop] Function.const ℝ 1

tactic: exact isEquivalent_one_sub_smoothingFn_one
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
c : ℝ
hc : c < 1
⊢ (fun x => 1 - ε x) ~[atTop] Function.const ℝ 1
state_after: no goals
Theorem: mul_inv_eq_of_eq_mul
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp [h]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : a = c * b
⊢ a * b⁻¹ = c
state_after: no goals
Theorem: ContinuousOn.preimage_isClosed_of_isClosed
File: Mathlib/Topology/ContinuousOn.lean

tactic: rcases continuousOn_iff_isClosed.1 hf t ht with ⟨u, hu⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
t : Set β
hf : ContinuousOn f s
hs : IsClosed s
ht : IsClosed t
⊢ IsClosed (s ∩ f ⁻¹' t)
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
t : Set β
hf : ContinuousOn f s
hs : IsClosed s
ht : IsClosed t
u : Set α
hu : IsClosed u ∧ f ⁻¹' t ∩ s = u ∩ s
⊢ IsClosed (s ∩ f ⁻¹' t)

tactic: rw [inter_comm, hu.2]
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
t : Set β
hf : ContinuousOn f s
hs : IsClosed s
ht : IsClosed t
u : Set α
hu : IsClosed u ∧ f ⁻¹' t ∩ s = u ∩ s
⊢ IsClosed (s ∩ f ⁻¹' t)
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
t : Set β
hf : ContinuousOn f s
hs : IsClosed s
ht : IsClosed t
u : Set α
hu : IsClosed u ∧ f ⁻¹' t ∩ s = u ∩ s
⊢ IsClosed (u ∩ s)

tactic: apply IsClosed.inter hu.1 hs
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
t : Set β
hf : ContinuousOn f s
hs : IsClosed s
ht : IsClosed t
u : Set α
hu : IsClosed u ∧ f ⁻¹' t ∩ s = u ∩ s
⊢ IsClosed (u ∩ s)
state_after: no goals
Theorem: OpenEmbedding.locallyConnectedSpace
File: Mathlib/Topology/Connected/LocallyConnected.lean

tactic: refine locallyConnectedSpace_of_connected_bases (fun _ s ↦ f ⁻¹' s)
  (fun x s ↦ (IsOpen s ∧ f x ∈ s ∧ IsConnected s) ∧ s ⊆ range f) (fun x ↦ ?_)
  (fun x s hxs ↦ hxs.1.2.2.isPreconnected.preimage_of_isOpenMap h.inj h.isOpenMap hxs.2)
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝² : TopologicalSpace α
s t u v : Set α
inst✝¹ : LocallyConnectedSpace α
inst✝ : TopologicalSpace β
f : β → α
h : OpenEmbedding f
⊢ LocallyConnectedSpace β
state_after: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝² : TopologicalSpace α
s t u v : Set α
inst✝¹ : LocallyConnectedSpace α
inst✝ : TopologicalSpace β
f : β → α
h : OpenEmbedding f
x : β
⊢ (𝓝 x).HasBasis ((fun x s => (IsOpen s ∧ f x ∈ s ∧ IsConnected s) ∧ s ⊆ range f) x) ((fun x s => f ⁻¹' s) x)

tactic: rw [h.nhds_eq_comap]
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝² : TopologicalSpace α
s t u v : Set α
inst✝¹ : LocallyConnectedSpace α
inst✝ : TopologicalSpace β
f : β → α
h : OpenEmbedding f
x : β
⊢ (𝓝 x).HasBasis ((fun x s => (IsOpen s ∧ f x ∈ s ∧ IsConnected s) ∧ s ⊆ range f) x) ((fun x s => f ⁻¹' s) x)
state_after: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝² : TopologicalSpace α
s t u v : Set α
inst✝¹ : LocallyConnectedSpace α
inst✝ : TopologicalSpace β
f : β → α
h : OpenEmbedding f
x : β
⊢ (Filter.comap f (𝓝 (f x))).HasBasis ((fun x s => (IsOpen s ∧ f x ∈ s ∧ IsConnected s) ∧ s ⊆ range f) x)
    ((fun x s => f ⁻¹' s) x)

tactic: exact LocallyConnectedSpace.open_connected_basis (f x) |>.restrict_subset
  (h.isOpen_range.mem_nhds <| mem_range_self _) |>.comap _
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝² : TopologicalSpace α
s t u v : Set α
inst✝¹ : LocallyConnectedSpace α
inst✝ : TopologicalSpace β
f : β → α
h : OpenEmbedding f
x : β
⊢ (Filter.comap f (𝓝 (f x))).HasBasis ((fun x s => (IsOpen s ∧ f x ∈ s ∧ IsConnected s) ∧ s ⊆ range f) x)
    ((fun x s => f ⁻¹' s) x)
state_after: no goals
Theorem: Computable.option_casesOn
File: Mathlib/Computability/Partrec.lean

tactic: cases o a <;> simp [encodek]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
o : α → Option β
f : α → σ
g : α → β → σ
ho : Computable o
hf : Computable f
hg : Computable₂ g
a : α
⊢ (Nat.casesOn (encode (o a)) (Option.some (f a)) fun n => Option.map (g a) (decode n)) =
    Option.some (Option.casesOn (o a) (f a) (g a))
state_after: no goals
Theorem: FractionalIdeal.le_spanSingleton_mul_iff
File: Mathlib/RingTheory/FractionalIdeal/Operations.lean

tactic: simp only [mem_singleton_mul, eq_comm]
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
R₁ : Type u_3
inst✝⁴ : CommRing R₁
K : Type u_4
inst✝³ : Field K
inst✝² : Algebra R₁ K
inst✝¹ : IsFractionRing R₁ K
inst✝ : IsDomain R₁
x : P
I J : FractionalIdeal S P
⊢ (∀ {zI : P}, zI ∈ I → zI ∈ spanSingleton S x * J) ↔ ∀ zI ∈ I, ∃ zJ ∈ J, x * zJ = zI
state_after: no goals
Theorem: DFA.mem_accepts
File: Mathlib/Computability/DFA.lean

tactic: rfl
state_before: α : Type u
σ : Type v
M : DFA α σ
x : List α
⊢ x ∈ M.accepts ↔ M.evalFrom M.start x ∈ M.accept
state_after: no goals
Theorem: Sum.Lex.Ico_inr_inr
File: Mathlib/Data/Sum/Interval.lean

tactic: rw [← Finset.map_map]
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ico (inrₗ b₁) (inrₗ b₂) = map (Embedding.inr.trans toLex.toEmbedding) (Ico b₁ b₂)
state_after: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ico (inrₗ b₁) (inrₗ b₂) = map toLex.toEmbedding (map Embedding.inr (Ico b₁ b₂))

tactic: rfl
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ico (inrₗ b₁) (inrₗ b₂) = map toLex.toEmbedding (map Embedding.inr (Ico b₁ b₂))
state_after: no goals
Theorem: List.reverse_range'
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: rw [range'_1_concat, reverse_append, range_succ_eq_map,
  show s + (n + 1) - 1 = s + n from rfl, map, map_map]
state_before: s n : Nat
⊢ (range' s (n + 1)).reverse = map (fun x => s + (n + 1) - 1 - x) (range (n + 1))
state_after: s n : Nat
⊢ [s + n].reverse ++ (range' s n).reverse = (s + n - 0) :: map ((fun x => s + n - x) ∘ succ) (range n)

tactic: simp [reverse_range', Nat.sub_right_comm, Nat.sub_sub]
state_before: s n : Nat
⊢ [s + n].reverse ++ (range' s n).reverse = (s + n - 0) :: map ((fun x => s + n - x) ∘ succ) (range n)
state_after: no goals
Theorem: Ordinal.lt_blsub_iff
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simpa only [not_forall, not_lt, not_le] using not_congr (@blsub_le_iff.{_, v} _ f a)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v}
a : Ordinal.{max u v}
⊢ a < o.blsub f ↔ ∃ i, ∃ (hi : i < o), a ≤ f i hi
state_after: no goals
Theorem: CategoryTheory.Core.id_hom
File: Mathlib/CategoryTheory/Core.lean

tactic: rfl
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X : C
⊢ (𝟙 X).hom = 𝟙 X
state_after: no goals
Theorem: Ordnode.Bounded.weak_right
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: cases o₁ <;> trivial
state_before: α : Type u_1
inst✝ : Preorder α
o₁ : WithBot α
o₂ : WithTop α
h : nil.Bounded o₁ o₂
⊢ nil.Bounded o₁ ⊤
state_after: no goals
Theorem: Units.mul_eq_one_iff_eq_inv
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [← mul_inv_eq_one, inv_inv]
state_before: α : Type u
inst✝ : Monoid α
a✝ b c u : αˣ
a : α
⊢ a * ↑u = 1 ↔ a = ↑u⁻¹
state_after: no goals
Theorem: isPiSystem_Ixx
File: Mathlib/MeasureTheory/PiSystem.lean

tactic: simpa only [exists_range_iff] using isPiSystem_Ixx_mem (@Hne) (@Hi) (range f) (range g)
state_before: α : Type u_1
ι : Sort u_2
ι' : Sort u_3
inst✝ : LinearOrder α
Ixx : α → α → Set α
p : α → α → Prop
Hne : ∀ {a b : α}, (Ixx a b).Nonempty → p a b
Hi : ∀ {a₁ b₁ a₂ b₂ : α}, Ixx a₁ b₁ ∩ Ixx a₂ b₂ = Ixx (max a₁ a₂) (min b₁ b₂)
f : ι → α
g : ι' → α
⊢ IsPiSystem {S | ∃ i j, p (f i) (g j) ∧ Ixx (f i) (g j) = S}
state_after: no goals
Theorem: MvPolynomial.eval₂_X
File: Mathlib/Algebra/MvPolynomial/Basic.lean

tactic: simp [eval₂_monomial, f.map_one, X, prod_single_index, pow_one]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
g : σ → S₁
n : σ
⊢ eval₂ f g (X n) = g n
state_after: no goals
Theorem: Polynomial.natDegree_eq_of_degree_eq
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: unfold natDegree
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
p q✝ r : R[X]
inst✝ : Semiring S
q : S[X]
h : p.degree = q.degree
⊢ p.natDegree = q.natDegree
state_after: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
p q✝ r : R[X]
inst✝ : Semiring S
q : S[X]
h : p.degree = q.degree
⊢ WithBot.unbot' 0 p.degree = WithBot.unbot' 0 q.degree

tactic: rw [h]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
p q✝ r : R[X]
inst✝ : Semiring S
q : S[X]
h : p.degree = q.degree
⊢ WithBot.unbot' 0 p.degree = WithBot.unbot' 0 q.degree
state_after: no goals
Theorem: NNRat.num_pos
File: Mathlib/Data/NNRat/Defs.lean

tactic: simp [pos_iff_ne_zero]
state_before: p q : ℚ≥0
⊢ 0 < q.num ↔ 0 < q
state_after: no goals
Theorem: Orientation.areaForm_swap
File: Mathlib/Analysis/InnerProductSpace/TwoDim.lean

tactic: simp only [areaForm_to_volumeForm]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ (o.areaForm x) y = -(o.areaForm y) x
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ o.volumeForm ![x, y] = -o.volumeForm ![y, x]

tactic: convert o.volumeForm.map_swap ![y, x] (_ : (0 : Fin 2) ≠ 1)
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ o.volumeForm ![x, y] = -o.volumeForm ![y, x]
state_after: case h.e'_2.h.e'_6
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ ![x, y] = ![y, x] ∘ ⇑(Equiv.swap 0 1)

E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ 0 ≠ 1

tactic: ext i
state_before: case h.e'_2.h.e'_6
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ ![x, y] = ![y, x] ∘ ⇑(Equiv.swap 0 1)
state_after: case h.e'_2.h.e'_6.h
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
i : Fin (Nat.succ 1)
⊢ ![x, y] i = (![y, x] ∘ ⇑(Equiv.swap 0 1)) i

tactic: fin_cases i <;> rfl
state_before: case h.e'_2.h.e'_6.h
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
i : Fin (Nat.succ 1)
⊢ ![x, y] i = (![y, x] ∘ ⇑(Equiv.swap 0 1)) i
state_after: no goals

tactic: norm_num
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ 0 ≠ 1
state_after: no goals
Theorem: Nat.coprime_self_sub_right
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: rw [Coprime, Coprime, gcd_self_sub_right h]
state_before: m n : ℕ
h : m ≤ n
⊢ n.Coprime (n - m) ↔ n.Coprime m
state_after: no goals
Theorem: expMapCircle_zero
File: Mathlib/Analysis/Complex/Circle.lean

tactic: rw [expMapCircle_apply, ofReal_zero, zero_mul, exp_zero, Submonoid.coe_one]
state_before: ⊢ ↑(expMapCircle 0) = ↑1
state_after: no goals
Theorem: Relation.TransGen.head_induction_on
File: Mathlib/Logic/Relation.lean

tactic: exact base h
state_before: case single
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝ b c d a b✝ : α
h : r a b✝
P : (a : α) → TransGen r a b✝ → Prop
base : ∀ {a : α} (h : r a b✝), P a ⋯
ih : ∀ {a c : α} (h' : r a c) (h : TransGen r c b✝), P c h → P a ⋯
⊢ P a ⋯
state_after: no goals

tactic: apply h_ih
state_before: case tail
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝¹ b✝ c✝ d a b c : α
a✝ : TransGen r a b
hbc : r b c
h_ih :
  ∀ {P : (a : α) → TransGen r a b → Prop},
    (∀ {a : α} (h : r a b), P a ⋯) → (∀ {a c : α} (h' : r a c) (h : TransGen r c b), P c h → P a ⋯) → P a a✝
P : (a : α) → TransGen r a c → Prop
base : ∀ {a : α} (h : r a c), P a ⋯
ih : ∀ {a c_1 : α} (h' : r a c_1) (h : TransGen r c_1 c), P c_1 h → P a ⋯
⊢ P a ⋯
state_after: case tail.base
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝¹ b✝ c✝ d a b c : α
a✝ : TransGen r a b
hbc : r b c
h_ih :
  ∀ {P : (a : α) → TransGen r a b → Prop},
    (∀ {a : α} (h : r a b), P a ⋯) → (∀ {a c : α} (h' : r a c) (h : TransGen r c b), P c h → P a ⋯) → P a a✝
P : (a : α) → TransGen r a c → Prop
base : ∀ {a : α} (h : r a c), P a ⋯
ih : ∀ {a c_1 : α} (h' : r a c_1) (h : TransGen r c_1 c), P c_1 h → P a ⋯
⊢ ∀ {a : α} (h : r a b), P a ⋯

case tail.ih
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝¹ b✝ c✝ d a b c : α
a✝ : TransGen r a b
hbc : r b c
h_ih :
  ∀ {P : (a : α) → TransGen r a b → Prop},
    (∀ {a : α} (h : r a b), P a ⋯) → (∀ {a c : α} (h' : r a c) (h : TransGen r c b), P c h → P a ⋯) → P a a✝
P : (a : α) → TransGen r a c → Prop
base : ∀ {a : α} (h : r a c), P a ⋯
ih : ∀ {a c_1 : α} (h' : r a c_1) (h : TransGen r c_1 c), P c_1 h → P a ⋯
⊢ ∀ {a c_1 : α} (h' : r a c_1) (h : TransGen r c_1 b), P c_1 ⋯ → P a ⋯

tactic: exact fun h ↦ ih h (single hbc) (base hbc)
state_before: case tail.base
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝¹ b✝ c✝ d a b c : α
a✝ : TransGen r a b
hbc : r b c
h_ih :
  ∀ {P : (a : α) → TransGen r a b → Prop},
    (∀ {a : α} (h : r a b), P a ⋯) → (∀ {a c : α} (h' : r a c) (h : TransGen r c b), P c h → P a ⋯) → P a a✝
P : (a : α) → TransGen r a c → Prop
base : ∀ {a : α} (h : r a c), P a ⋯
ih : ∀ {a c_1 : α} (h' : r a c_1) (h : TransGen r c_1 c), P c_1 h → P a ⋯
⊢ ∀ {a : α} (h : r a b), P a ⋯
state_after: no goals

tactic: exact fun hab hbc ↦ ih hab _
state_before: case tail.ih
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝¹ b✝ c✝ d a b c : α
a✝ : TransGen r a b
hbc : r b c
h_ih :
  ∀ {P : (a : α) → TransGen r a b → Prop},
    (∀ {a : α} (h : r a b), P a ⋯) → (∀ {a c : α} (h' : r a c) (h : TransGen r c b), P c h → P a ⋯) → P a a✝
P : (a : α) → TransGen r a c → Prop
base : ∀ {a : α} (h : r a c), P a ⋯
ih : ∀ {a c_1 : α} (h' : r a c_1) (h : TransGen r c_1 c), P c_1 h → P a ⋯
⊢ ∀ {a c_1 : α} (h' : r a c_1) (h : TransGen r c_1 b), P c_1 ⋯ → P a ⋯
state_after: no goals
Theorem: Finset.prod_preimage'
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: classical
calc
  ∏ x ∈ preimage s f hf, g (f x) = ∏ x ∈ image f (preimage s f hf), g x :=
    Eq.symm <| prod_image <| by simpa only [mem_preimage, Set.InjOn] using hf
  _ = ∏ x ∈ s.filter fun x => x ∈ Set.range f, g x := by rw [image_preimage]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
f : ι → κ
inst✝ : DecidablePred fun x => x ∈ Set.range f
s : Finset κ
hf : Set.InjOn f (f ⁻¹' ↑s)
g : κ → β
⊢ ∏ x ∈ s.preimage f hf, g (f x) = ∏ x ∈ filter (fun x => x ∈ Set.range f) s, g x
state_after: no goals

tactic: calc
  ∏ x ∈ preimage s f hf, g (f x) = ∏ x ∈ image f (preimage s f hf), g x :=
    Eq.symm <| prod_image <| by simpa only [mem_preimage, Set.InjOn] using hf
  _ = ∏ x ∈ s.filter fun x => x ∈ Set.range f, g x := by rw [image_preimage]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
f : ι → κ
inst✝ : DecidablePred fun x => x ∈ Set.range f
s : Finset κ
hf : Set.InjOn f (f ⁻¹' ↑s)
g : κ → β
⊢ ∏ x ∈ s.preimage f hf, g (f x) = ∏ x ∈ filter (fun x => x ∈ Set.range f) s, g x
state_after: no goals

tactic: simpa only [mem_preimage, Set.InjOn] using hf
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
f : ι → κ
inst✝ : DecidablePred fun x => x ∈ Set.range f
s : Finset κ
hf : Set.InjOn f (f ⁻¹' ↑s)
g : κ → β
⊢ ∀ x ∈ s.preimage f hf, ∀ y ∈ s.preimage f hf, f x = f y → x = y
state_after: no goals

tactic: rw [image_preimage]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
f : ι → κ
inst✝ : DecidablePred fun x => x ∈ Set.range f
s : Finset κ
hf : Set.InjOn f (f ⁻¹' ↑s)
g : κ → β
⊢ ∏ x ∈ image f (s.preimage f hf), g x = ∏ x ∈ filter (fun x => x ∈ Set.range f) s, g x
state_after: no goals
Theorem: Equiv.Perm.IsCycle.ne_one
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: simp [hf, IsCycle] at h
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
h : f.IsCycle
hf : f = 1
⊢ False
state_after: no goals