tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Limits.inv_prodComparison_map_fst
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: simp [IsIso.inv_comp_eq]
state_before: C : Type u
inst✝⁶ : Category C
X Y : C
D : Type u₂
inst✝⁵ : Category D
F : C ⥤ D
A A' B B' : C
inst✝⁴ : HasBinaryProduct A B
inst✝³ : HasBinaryProduct A' B'
inst✝² : HasBinaryProduct (F.obj A) (F.obj B)
inst✝¹ : HasBinaryProduct (F.obj A') (F.obj B')
inst✝ : IsIso (prodComparison F A B)
⊢ inv (prodComparison F A B) ≫ F.map prod.fst = prod.fst
Theorem: Lagrange.degree_basisDivisor_of_ne
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [basisDivisor, degree_mul, degree_X_sub_C, degree_C, zero_add]
state_before: F : Type u_1
inst✝ : Field F
x y : F
hxy : x ≠ y
⊢ degree (basisDivisor x y) = 1

tactic: exact inv_ne_zero (sub_ne_zero_of_ne hxy)
state_before: F : Type u_1
inst✝ : Field F
x y : F
hxy : x ≠ y
⊢ (x - y)⁻¹ ≠ 0
Theorem: SimpleGraph.ComponentCompl.hom_trans
File: Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean

tactic: change C.map _ = (C.map _).map _
state_before: V : Type u
G : SimpleGraph V
K L L' M : Set V
C : ComponentCompl G L
h : K ⊆ L
h' : M ⊆ K
⊢ hom (_ : M ⊆ L) C = hom h' (hom h C)

tactic: erw [ConnectedComponent.map_comp, induceHom_comp]
state_before: V : Type u
G : SimpleGraph V
K L L' M : Set V
C : ComponentCompl G L
h : K ⊆ L
h' : M ⊆ K
⊢ ConnectedComponent.map (InduceHom Hom.id (_ : Lᶜ ⊆ Mᶜ)) C =
    ConnectedComponent.map (InduceHom Hom.id (_ : Kᶜ ⊆ Mᶜ)) (ConnectedComponent.map (InduceHom Hom.id (_ : Lᶜ ⊆ Kᶜ)) C)

tactic: rfl
state_before: V : Type u
G : SimpleGraph V
K L L' M : Set V
C : ComponentCompl G L
h : K ⊆ L
h' : M ⊆ K
⊢ ConnectedComponent.map (InduceHom Hom.id (_ : Lᶜ ⊆ Mᶜ)) C =
    ConnectedComponent.map
      (InduceHom (Hom.comp Hom.id Hom.id) (_ : Set.MapsTo (↑Hom.id ∘ fun x => ↑Hom.id x) (Lᶜ) (Mᶜ))) C
Theorem: Lagrange.basisDivisor_inj
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: simp_rw [basisDivisor, mul_eq_zero, X_sub_C_ne_zero, or_false_iff, C_eq_zero, inv_eq_zero,
  sub_eq_zero] at hxy
state_before: F : Type u_1
inst✝ : Field F
x y : F
hxy : basisDivisor x y = 0
⊢ x = y

tactic: exact hxy
state_before: F : Type u_1
inst✝ : Field F
x y : F
hxy : x = y
⊢ x = y
Theorem: Substring.Valid.all
File: Std/Data/String/Lemmas.lean

tactic: simp [h.all, h.toString]
state_before: f : Char → Bool
x✝ : Substring
h✝ : Valid x✝
w✝² w✝¹ w✝ : List Char
h : ValidFor w✝² w✝¹ w✝ x✝
⊢ Substring.all x✝ f = List.all (toString x✝).data f
Theorem: NonarchimedeanGroup.prod_self_subset
File: Mathlib/Topology/Algebra/Nonarchimedean/Basic.lean

tactic: refine' Set.Subset.trans (Set.prod_mono _ _) ‹_› <;> simp
state_before: G : Type u_1
inst✝⁸ : Group G
inst✝⁷ : TopologicalSpace G
inst✝⁶ : NonarchimedeanGroup G
H : Type ?u.61803
inst✝⁵ : Group H
inst✝⁴ : TopologicalSpace H
inst✝³ : TopologicalGroup H
K : Type ?u.61824
inst✝² : Group K
inst✝¹ : TopologicalSpace K
inst✝ : NonarchimedeanGroup K
U : Set (G × G)
hU : U ∈ nhds 1
V W : OpenSubgroup G
h : ↑V ×ˢ ↑W ⊆ U
⊢ ↑(V ⊓ W) ×ˢ ↑(V ⊓ W) ⊆ U
Theorem: contDiff_top_iff_deriv
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: simp only [← contDiffOn_univ, ← differentiableOn_univ, ← derivWithin_univ]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
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 ?u.3065764
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f₂ : 𝕜 → F
s₂ : Set 𝕜
⊢ ContDiff 𝕜 ⊤ f₂ ↔ Differentiable 𝕜 f₂ ∧ ContDiff 𝕜 ⊤ (deriv f₂)

tactic: rw [contDiffOn_top_iff_derivWithin uniqueDiffOn_univ]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
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 ?u.3065764
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f₂ : 𝕜 → F
s₂ : Set 𝕜
⊢ ContDiffOn 𝕜 ⊤ f₂ univ ↔ DifferentiableOn 𝕜 f₂ univ ∧ ContDiffOn 𝕜 ⊤ (derivWithin f₂ univ) univ
Theorem: skewAdjoint.conjugate
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: simp only [mem_iff, star_mul, star_star, mem_iff.mp hx, neg_mul, mul_neg, mul_assoc]
state_before: R : Type u_1
A : Type ?u.109551
inst✝¹ : Ring R
inst✝ : StarRing R
x : R
hx : x ∈ skewAdjoint R
z : R
⊢ z * x * star z ∈ skewAdjoint R
Theorem: MeasureTheory.isLocallyFiniteMeasure_of_smulInvariant
File: Mathlib/MeasureTheory/Group/Action.lean

tactic: rwa [measure_preimage_smul]
state_before: G : Type ?u.57418
M : Type ?u.57421
α : Type u_1
s : Set α
m : MeasurableSpace α
inst✝⁷ : Group G
inst✝⁶ : MulAction G α
inst✝⁵ : MeasurableSpace G
inst✝⁴ : MeasurableSMul G α
c : G
μ : Measure α
inst✝³ : SMulInvariantMeasure G α μ
inst✝² : TopologicalSpace α
inst✝¹ : ContinuousConstSMul G α
inst✝ : MulAction.IsMinimal G α
K U : Set α
hU : IsOpen U
hne : Set.Nonempty U
hμU : ↑↑μ U ≠ ⊤
x : α
g : G
hg : g • x ∈ U
⊢ ↑↑μ ((fun x x_1 => x • x_1) g ⁻¹' U) ≠ ⊤
Theorem: IsSelfAdjoint.adjoint_conj
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: rw [isSelfAdjoint_iff'] at hT⊢
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.1357503
inst✝⁸ : IsROrC 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : InnerProductSpace 𝕜 F
inst✝² : InnerProductSpace 𝕜 G
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
T : E →L[𝕜] E
hT : IsSelfAdjoint T
S : F →L[𝕜] E
⊢ IsSelfAdjoint (comp (↑adjoint S) (comp T S))

tactic: simp only [hT, adjoint_comp, adjoint_adjoint]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.1357503
inst✝⁸ : IsROrC 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : InnerProductSpace 𝕜 F
inst✝² : InnerProductSpace 𝕜 G
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
T : E →L[𝕜] E
hT : ↑adjoint T = T
S : F →L[𝕜] E
⊢ ↑adjoint (comp (↑adjoint S) (comp T S)) = comp (↑adjoint S) (comp T S)

tactic: exact ContinuousLinearMap.comp_assoc _ _ _
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.1357503
inst✝⁸ : IsROrC 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : InnerProductSpace 𝕜 F
inst✝² : InnerProductSpace 𝕜 G
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
T : E →L[𝕜] E
hT : ↑adjoint T = T
S : F →L[𝕜] E
⊢ comp (comp (↑adjoint S) T) S = comp (↑adjoint S) (comp T S)
Theorem: Fin.prod_ofFn
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: rw [List.ofFn_eq_map, prod_univ_def]
state_before: α : Type ?u.2004
β : Type u_1
inst✝ : CommMonoid β
n : ℕ
f : Fin n → β
⊢ List.prod (List.ofFn f) = ∏ i : Fin n, f i
Theorem: List.filter_eq_self
File: Std/Data/List/Lemmas.lean

tactic: induction l with simp
| cons a l ih =>
  cases h : p a <;> simp [*]
  intro h; exact Nat.lt_irrefl _ (h ▸ length_filter_le p l)
state_before: α✝ : Type u_1
p : α✝ → Bool
l : List α✝
⊢ filter p l = l ↔ ∀ (a : α✝), a ∈ l → p a = true

tactic: cases h : p a <;> simp [*]
state_before: case cons
α✝ : Type u_1
p : α✝ → Bool
a : α✝
l : List α✝
ih : filter p l = l ↔ ∀ (a : α✝), a ∈ l → p a = true
⊢ filter p (a :: l) = a :: l ↔ p a = true ∧ ∀ (a : α✝), a ∈ l → p a = true

tactic: intro h
state_before: case cons.false
α✝ : Type u_1
p : α✝ → Bool
a : α✝
l : List α✝
ih : filter p l = l ↔ ∀ (a : α✝), a ∈ l → p a = true
h : p a = false
⊢ ¬filter p l = a :: l

tactic: exact Nat.lt_irrefl _ (h ▸ length_filter_le p l)
state_before: case cons.false
α✝ : Type u_1
p : α✝ → Bool
a : α✝
l : List α✝
ih : filter p l = l ↔ ∀ (a : α✝), a ∈ l → p a = true
h✝ : p a = false
h : filter p l = a :: l
⊢ False
Theorem: ContinuousMultilinearMap.curryFinFinset_apply_const
File: Mathlib/Analysis/NormedSpace/Multilinear.lean

tactic: refine' (curryFinFinset_symm_apply_piecewise_const hk hl _ _ _).symm.trans _
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
k l : ℕ
s : Finset (Fin n)
hk : card s = k
hl : card (sᶜ) = l
f : ContinuousMultilinearMap 𝕜 (fun i => G) G'
x y : G
⊢ (↑(↑(↑(curryFinFinset 𝕜 G G' hk hl) f) fun x_1 => x) fun x => y) = ↑f (piecewise s (fun x_1 => x) fun x => y)

tactic: rw [LinearIsometryEquiv.symm_apply_apply]
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
k l : ℕ
s : Finset (Fin n)
hk : card s = k
hl : card (sᶜ) = l
f : ContinuousMultilinearMap 𝕜 (fun i => G) G'
x y : G
⊢ ↑(↑(LinearIsometryEquiv.symm (curryFinFinset 𝕜 G G' hk hl)) (↑(curryFinFinset 𝕜 G G' hk hl) f))
      (piecewise s (fun x_1 => x) fun x => y) =
    ↑f (piecewise s (fun x_1 => x) fun x => y)
Theorem: Traversable.foldlm_toList
File: Mathlib/Control/Fold.lean

tactic: simp only [foldlm, toList_spec, foldMap_hom_free (foldlM.ofFreeMonoid f),
 foldlm.ofFreeMonoid_comp_of, foldlM.get, FreeMonoid.ofList_toList]
state_before: α β γ : Type u
t : Type u → Type u
inst✝³ : Traversable t
inst✝² : IsLawfulTraversable t
m : Type u → Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m α
x : α
xs : t β
⊢ foldlm f x xs = unop (↑(foldlM.ofFreeMonoid f) (↑FreeMonoid.ofList (toList xs))) x

tactic: simp [foldlM.ofFreeMonoid, unop_op, flip]
state_before: α β γ : Type u
t : Type u → Type u
inst✝³ : Traversable t
inst✝² : IsLawfulTraversable t
m : Type u → Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m α
x : α
xs : t β
⊢ unop (↑(foldlM.ofFreeMonoid f) (↑FreeMonoid.ofList (toList xs))) x = List.foldlM f x (toList xs)
Theorem: dense_of_exists_between
File: Mathlib/Topology/Order/Basic.lean

tactic: refine dense_iff_inter_open.2 fun U U_open U_nonempty => ?_
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
s : Set α
h : ∀ ⦃a b : α⦄, a < b → ∃ c, c ∈ s ∧ a < c ∧ c < b
⊢ Dense s

tactic: obtain ⟨a, b, hab, H⟩ : ∃ a b : α, a < b ∧ Ioo a b ⊆ U := U_open.exists_Ioo_subset U_nonempty
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
s : Set α
h : ∀ ⦃a b : α⦄, a < b → ∃ c, c ∈ s ∧ a < c ∧ c < b
U : Set α
U_open : IsOpen U
U_nonempty : Set.Nonempty U
⊢ Set.Nonempty (U ∩ s)

tactic: obtain ⟨x, xs, hx⟩ : ∃ x ∈ s, a < x ∧ x < b := h hab
state_before: case intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
s : Set α
h : ∀ ⦃a b : α⦄, a < b → ∃ c, c ∈ s ∧ a < c ∧ c < b
U : Set α
U_open : IsOpen U
U_nonempty : Set.Nonempty U
a b : α
hab : a < b
H : Ioo a b ⊆ U
⊢ Set.Nonempty (U ∩ s)

tactic: exact ⟨x, ⟨H hx, xs⟩⟩
state_before: case intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
s : Set α
h : ∀ ⦃a b : α⦄, a < b → ∃ c, c ∈ s ∧ a < c ∧ c < b
U : Set α
U_open : IsOpen U
U_nonempty : Set.Nonempty U
a b : α
hab : a < b
H : Ioo a b ⊆ U
x : α
xs : x ∈ s
hx : a < x ∧ x < b
⊢ Set.Nonempty (U ∩ s)
Theorem: Rat.le_floor
File: Mathlib/Data/Rat/Floor.lean

tactic: simp [Rat.floor_def']
state_before: α : Type ?u.897
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
z n : ℤ
d : ℕ
h : d ≠ 0
c : Nat.coprime (natAbs n) d
⊢ z ≤ Rat.floor (mk' n d) ↔ ↑z ≤ mk' n d

tactic: rw [num_den']
state_before: α : Type ?u.897
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
z n : ℤ
d : ℕ
h : d ≠ 0
c : Nat.coprime (natAbs n) d
⊢ z ≤ n / ↑d ↔ ↑z ≤ mk' n d

tactic: have h' := Int.ofNat_lt.2 (Nat.pos_of_ne_zero h)
state_before: α : Type ?u.897
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
z n : ℤ
d : ℕ
h : d ≠ 0
c : Nat.coprime (natAbs n) d
⊢ z ≤ n / ↑d ↔ ↑z ≤ n /. ↑d

tactic: conv =>
  rhs
  rw [coe_int_eq_divInt, Rat.le_def zero_lt_one h', mul_one]
state_before: α : Type ?u.897
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
z n : ℤ
d : ℕ
h : d ≠ 0
c : Nat.coprime (natAbs n) d
h' : ↑0 < ↑d
⊢ z ≤ n / ↑d ↔ ↑z ≤ n /. ↑d

tactic: exact Int.le_ediv_iff_mul_le h'
state_before: α : Type ?u.897
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
z n : ℤ
d : ℕ
h : d ≠ 0
c : Nat.coprime (natAbs n) d
h' : ↑0 < ↑d
⊢ z ≤ n / ↑d ↔ z * ↑d ≤ n
Theorem: Function.mulSupport_prod_mk'
File: Mathlib/Algebra/Support.lean

tactic: simp only [← mulSupport_prod_mk, Prod.mk.eta]
state_before: α : Type u_3
β : Type ?u.16880
A : Type ?u.16883
B : Type ?u.16886
M : Type u_1
N : Type u_2
P : Type ?u.16895
R : Type ?u.16898
S : Type ?u.16901
G : Type ?u.16904
M₀ : Type ?u.16907
G₀ : Type ?u.16910
ι : Sort ?u.16913
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : α → M × N
⊢ mulSupport f = (mulSupport fun x => (f x).fst) ∪ mulSupport fun x => (f x).snd
Theorem: Cardinal.isUnit_iff
File: Mathlib/SetTheory/Cardinal/Divisibility.lean

tactic: refine'
  ⟨fun h => _, by
    rintro rfl
    exact isUnit_one⟩
state_before: a b : Cardinal
n m : ℕ
⊢ IsUnit a ↔ a = 1

tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: a b : Cardinal
n m : ℕ
h : IsUnit a
⊢ a = 1

tactic: rw [isUnit_iff_forall_dvd] at h
state_before: case inr
a b : Cardinal
n m : ℕ
h : IsUnit a
ha : a ≠ 0
⊢ a = 1

tactic: cases' h 1 with t ht
state_before: case inr
a b : Cardinal
n m : ℕ
h : ∀ (y : Cardinal), a ∣ y
ha : a ≠ 0
⊢ a = 1

tactic: rw [eq_comm, mul_eq_one_iff'] at ht
state_before: case inr.intro
a b : Cardinal
n m : ℕ
h : ∀ (y : Cardinal), a ∣ y
ha : a ≠ 0
t : Cardinal
ht : 1 = a * t
⊢ a = 1

tactic: rintro rfl
state_before: a b : Cardinal
n m : ℕ
⊢ a = 1 → IsUnit a

tactic: exact isUnit_one
state_before: b : Cardinal
n m : ℕ
⊢ IsUnit 1

tactic: exact (not_isUnit_zero h).elim
state_before: case inl
b : Cardinal
n m : ℕ
h : IsUnit 0
⊢ 0 = 1

tactic: exact ht.1
state_before: case inr.intro
a b : Cardinal
n m : ℕ
h : ∀ (y : Cardinal), a ∣ y
ha : a ≠ 0
t : Cardinal
ht : a = 1 ∧ t = 1
⊢ a = 1

tactic: exact one_le_iff_ne_zero.mpr ha
state_before: case inr.intro.ha
a b : Cardinal
n m : ℕ
h : ∀ (y : Cardinal), a ∣ y
ha : a ≠ 0
t : Cardinal
ht : a * t = 1
⊢ 1 ≤ a

tactic: apply one_le_iff_ne_zero.mpr
state_before: case inr.intro.hb
a b : Cardinal
n m : ℕ
h : ∀ (y : Cardinal), a ∣ y
ha : a ≠ 0
t : Cardinal
ht : a * t = 1
⊢ 1 ≤ t

tactic: intro h
state_before: case inr.intro.hb
a b : Cardinal
n m : ℕ
h : ∀ (y : Cardinal), a ∣ y
ha : a ≠ 0
t : Cardinal
ht : a * t = 1
⊢ t ≠ 0

tactic: rw [h, mul_zero] at ht
state_before: case inr.intro.hb
a b : Cardinal
n m : ℕ
h✝ : ∀ (y : Cardinal), a ∣ y
ha : a ≠ 0
t : Cardinal
ht : a * t = 1
h : t = 0
⊢ False

tactic: exact zero_ne_one ht
state_before: case inr.intro.hb
a b : Cardinal
n m : ℕ
h✝ : ∀ (y : Cardinal), a ∣ y
ha : a ≠ 0
t : Cardinal
ht : 0 = 1
h : t = 0
⊢ False
Theorem: AntilipschitzWith.mul_le_edist
File: Mathlib/Topology/MetricSpace/Antilipschitz.lean

tactic: rw [mul_comm, ← div_eq_mul_inv]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.4707
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f : α → β
hf : AntilipschitzWith K f
x y : α
⊢ (↑K)⁻¹ * edist x y ≤ edist (f x) (f y)

tactic: exact ENNReal.div_le_of_le_mul' (hf x y)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.4707
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f : α → β
hf : AntilipschitzWith K f
x y : α
⊢ edist x y / ↑K ≤ edist (f x) (f y)
Theorem: WittVector.mulIsPoly₂
File: Mathlib/RingTheory/WittVector/IsPoly.lean

tactic: intros
state_before: p : ℕ
R S : Type u
σ : Type ?u.696391
idx : Type ?u.696394
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Fact (Nat.Prime p)
⊢ ∀ ⦃R : Type u_1⦄ [inst : CommRing R] (x y : 𝕎 R), (x * y).coeff = fun n => peval (wittMul p n) ![x.coeff, y.coeff]

tactic: ext
state_before: p : ℕ
R S : Type u
σ : Type ?u.696391
idx : Type ?u.696394
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Fact (Nat.Prime p)
R✝ : Type u_1
inst✝ : CommRing R✝
x✝ y✝ : 𝕎 R✝
⊢ (x✝ * y✝).coeff = fun n => peval (wittMul p n) ![x✝.coeff, y✝.coeff]

tactic: exact mul_coeff _ _ _
state_before: case h
p : ℕ
R S : Type u
σ : Type ?u.696391
idx : Type ?u.696394
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Fact (Nat.Prime p)
R✝ : Type u_1
inst✝ : CommRing R✝
x✝¹ y✝ : 𝕎 R✝
x✝ : ℕ
⊢ coeff (x✝¹ * y✝) x✝ = peval (wittMul p x✝) ![x✝¹.coeff, y✝.coeff]
Theorem: Asymptotics.isBigOWith_principal
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: rw [IsBigOWith_def]
state_before: α : Type u_1
β : Type ?u.289553
E : Type u_2
F : Type u_3
G : Type ?u.289562
E' : Type ?u.289565
F' : Type ?u.289568
G' : Type ?u.289571
E'' : Type ?u.289574
F'' : Type ?u.289577
G'' : Type ?u.289580
R : Type ?u.289583
R' : Type ?u.289586
𝕜 : Type ?u.289589
𝕜' : Type ?u.289592
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✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
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 α
s : Set α
⊢ IsBigOWith c (𝓟 s) f g ↔ ∀ (x : α), x ∈ s → ‖f x‖ ≤ c * ‖g x‖

tactic: rfl
state_before: α : Type u_1
β : Type ?u.289553
E : Type u_2
F : Type u_3
G : Type ?u.289562
E' : Type ?u.289565
F' : Type ?u.289568
G' : Type ?u.289571
E'' : Type ?u.289574
F'' : Type ?u.289577
G'' : Type ?u.289580
R : Type ?u.289583
R' : Type ?u.289586
𝕜 : Type ?u.289589
𝕜' : Type ?u.289592
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✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
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 α
s : Set α
⊢ (∀ᶠ (x : α) in 𝓟 s, ‖f x‖ ≤ c * ‖g x‖) ↔ ∀ (x : α), x ∈ s → ‖f x‖ ≤ c * ‖g x‖
Theorem: List.destutter_eq_self_iff
File: Mathlib/Data/List/Destutter.lean

tactic: simp
state_before: α : Type u_1
l : List α
R : α → α → Prop
inst✝ : DecidableRel R
a b : α
⊢ destutter R [] = [] ↔ Chain' R []
Theorem: Rat.add_zero
File: Mathlib/Data/Rat/Defs.lean

tactic: rw [← zero_divInt d, add_def'', zero_mul, add_zero, divInt_mul_right] <;> simp [h]
state_before: a b c : ℚ
n : ℤ
d : ℕ
h : d ≠ 0
⊢ n /. ↑d + 0 = n /. ↑d
Theorem: FreeGroup.lift.range_le
File: Mathlib/GroupTheory/FreeGroup.lean

tactic: rintro _ ⟨⟨L⟩, rfl⟩
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
inst✝ : Group β
f : α → β
x y : FreeGroup α
s : Subgroup β
H : Set.range f ⊆ ↑s
⊢ MonoidHom.range (↑lift f) ≤ s

tactic: exact
  List.recOn L s.one_mem fun ⟨x, b⟩ tl ih =>
    Bool.recOn b (by simp at ih⊢; exact s.mul_mem (s.inv_mem <| H ⟨x, rfl⟩) ih)
      (by simp at ih⊢; exact s.mul_mem (H ⟨x, rfl⟩) ih)
state_before: case intro.mk
α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
inst✝ : Group β
f : α → β
x y : FreeGroup α
s : Subgroup β
H : Set.range f ⊆ ↑s
w✝ : FreeGroup α
L : List (α × Bool)
⊢ ↑(↑lift f) (Quot.mk Red.Step L) ∈ s

tactic: simp at ih⊢
state_before: α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
inst✝ : Group β
f : α → β
x✝¹ y : FreeGroup α
s : Subgroup β
H : Set.range f ⊆ ↑s
w✝ : FreeGroup α
L : List (α × Bool)
x✝ : α × Bool
tl : List (α × Bool)
ih : ↑(↑lift f) (Quot.mk Red.Step tl) ∈ s
x : α
b : Bool
⊢ ↑(↑lift f) (Quot.mk Red.Step ((x, false) :: tl)) ∈ s

tactic: exact s.mul_mem (s.inv_mem <| H ⟨x, rfl⟩) ih
state_before: α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
inst✝ : Group β
f : α → β
x✝¹ y : FreeGroup α
s : Subgroup β
H : Set.range f ⊆ ↑s
w✝ : FreeGroup α
L : List (α × Bool)
x✝ : α × Bool
tl : List (α × Bool)
ih : List.prod (List.map (fun x => bif x.snd then f x.fst else (f x.fst)⁻¹) tl) ∈ s
x : α
b : Bool
⊢ (f x)⁻¹ * List.prod (List.map (fun x => bif x.snd then f x.fst else (f x.fst)⁻¹) tl) ∈ s

tactic: simp at ih⊢
state_before: α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
inst✝ : Group β
f : α → β
x✝¹ y : FreeGroup α
s : Subgroup β
H : Set.range f ⊆ ↑s
w✝ : FreeGroup α
L : List (α × Bool)
x✝ : α × Bool
tl : List (α × Bool)
ih : ↑(↑lift f) (Quot.mk Red.Step tl) ∈ s
x : α
b : Bool
⊢ ↑(↑lift f) (Quot.mk Red.Step ((x, true) :: tl)) ∈ s

tactic: exact s.mul_mem (H ⟨x, rfl⟩) ih
state_before: α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
inst✝ : Group β
f : α → β
x✝¹ y : FreeGroup α
s : Subgroup β
H : Set.range f ⊆ ↑s
w✝ : FreeGroup α
L : List (α × Bool)
x✝ : α × Bool
tl : List (α × Bool)
ih : List.prod (List.map (fun x => bif x.snd then f x.fst else (f x.fst)⁻¹) tl) ∈ s
x : α
b : Bool
⊢ f x * List.prod (List.map (fun x => bif x.snd then f x.fst else (f x.fst)⁻¹) tl) ∈ s
Theorem: Filter.sInter_mem
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [sInter_eq_biInter, biInter_mem hfin]
state_before: α : Type u
f g : Filter α
s✝ t : Set α
s : Set (Set α)
hfin : Set.Finite s
⊢ ⋂₀ s ∈ f ↔ ∀ (U : Set α), U ∈ s → U ∈ f
Theorem: Finset.image₂_insert_left
File: Mathlib/Data/Finset/NAry.lean

tactic: push_cast
state_before: α : Type u_1
α' : Type ?u.36962
β : Type u_3
β' : Type ?u.36968
γ : Type u_2
γ' : Type ?u.36974
δ : Type ?u.36977
δ' : Type ?u.36980
ε : Type ?u.36983
ε' : Type ?u.36986
ζ : Type ?u.36989
ζ' : Type ?u.36992
ν : Type ?u.36995
inst✝⁸ : DecidableEq α'
inst✝⁷ : DecidableEq β'
inst✝⁶ : DecidableEq γ
inst✝⁵ : DecidableEq γ'
inst✝⁴ : DecidableEq δ
inst✝³ : DecidableEq δ'
inst✝² : DecidableEq ε
inst✝¹ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝ : DecidableEq α
⊢ ↑(image₂ f (insert a s) t) = ↑(image (fun b => f a b) t ∪ image₂ f s t)

tactic: exact image2_insert_left
state_before: α : Type u_1
α' : Type ?u.36962
β : Type u_3
β' : Type ?u.36968
γ : Type u_2
γ' : Type ?u.36974
δ : Type ?u.36977
δ' : Type ?u.36980
ε : Type ?u.36983
ε' : Type ?u.36986
ζ : Type ?u.36989
ζ' : Type ?u.36992
ν : Type ?u.36995
inst✝⁸ : DecidableEq α'
inst✝⁷ : DecidableEq β'
inst✝⁶ : DecidableEq γ
inst✝⁵ : DecidableEq γ'
inst✝⁴ : DecidableEq δ
inst✝³ : DecidableEq δ'
inst✝² : DecidableEq ε
inst✝¹ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝ : DecidableEq α
⊢ image2 f (insert a ↑s) ↑t = (fun b => f a b) '' ↑t ∪ image2 f ↑s ↑t