tasksource/leandojo huggingface dataset:
Theorem: SimpleGraph.Path.loop_eq
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: obtain ⟨_ | _, h⟩ := p
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v : V
p : Path G v v
⊢ p = Path.nil

tactic: rfl
state_before: case mk.nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v : V
h : Walk.IsPath Walk.nil
⊢ { val := Walk.nil, property := h } = Path.nil

tactic: simp at h
state_before: case mk.cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v v✝ : V
h✝ : Adj G v v✝
p✝ : Walk G v✝ v
h : Walk.IsPath (Walk.cons h✝ p✝)
⊢ { val := Walk.cons h✝ p✝, property := h } = Path.nil
Theorem: Set.mem_compl_image
File: Mathlib/Data/Set/Image.lean

tactic: simp [← preimage_compl_eq_image_compl]
state_before: α : Type u_1
β : Type ?u.38945
γ : Type ?u.38948
ι : Sort ?u.38951
ι' : Sort ?u.38954
f : α → β
s t✝ : Set α
inst✝ : BooleanAlgebra α
t : α
S : Set α
⊢ t ∈ compl '' S ↔ tᶜ ∈ S
Theorem: div_mul_eq_div_div_swap
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp only [mul_assoc, mul_inv_rev, div_eq_mul_inv]
state_before: α : Type u_1
β : Type ?u.29041
G : Type ?u.29044
inst✝ : DivisionMonoid α
a b c : α
⊢ a / (b * c) = a / c / b
Theorem: List.length_splitWrtCompositionAux
File: Mathlib/Combinatorics/Composition.lean

tactic: induction ns generalizing l
state_before: n : ℕ
α : Type u_1
l : List α
ns : List ℕ
⊢ length (splitWrtCompositionAux l ns) = length ns

tactic: . simp [splitWrtCompositionAux, *]
state_before: case nil
n : ℕ
α : Type u_1
l : List α
⊢ length (splitWrtCompositionAux l []) = length []

case cons
n : ℕ
α : Type u_1
head✝ : ℕ
tail✝ : List ℕ
tail_ih✝ : ∀ (l : List α), length (splitWrtCompositionAux l tail✝) = length tail✝
l : List α
⊢ length (splitWrtCompositionAux l (head✝ :: tail✝)) = length (head✝ :: tail✝)

tactic: . simp [*]
state_before: case cons
n : ℕ
α : Type u_1
head✝ : ℕ
tail✝ : List ℕ
tail_ih✝ : ∀ (l : List α), length (splitWrtCompositionAux l tail✝) = length tail✝
l : List α
⊢ length (splitWrtCompositionAux l (head✝ :: tail✝)) = length (head✝ :: tail✝)

tactic: simp [splitWrtCompositionAux, *]
state_before: case nil
n : ℕ
α : Type u_1
l : List α
⊢ length (splitWrtCompositionAux l []) = length []

tactic: simp [*]
state_before: case cons
n : ℕ
α : Type u_1
head✝ : ℕ
tail✝ : List ℕ
tail_ih✝ : ∀ (l : List α), length (splitWrtCompositionAux l tail✝) = length tail✝
l : List α
⊢ length (splitWrtCompositionAux l (head✝ :: tail✝)) = length (head✝ :: tail✝)
Theorem: iSup_option
File: Mathlib/Order/CompleteLattice.lean

tactic: simp only [iSup_le_iff, sup_le_iff, Option.forall]
state_before: α : Type u_2
β : Type u_1
β₂ : Type ?u.169814
γ : Type ?u.169817
ι : Sort ?u.169820
ι' : Sort ?u.169823
κ : ι → Sort ?u.169828
κ' : ι' → Sort ?u.169833
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : Option β → α
c : α
⊢ (⨆ (o : Option β), f o) ≤ c ↔ (f none ⊔ ⨆ (b : β), f (some b)) ≤ c
Theorem: Polynomial.coeff_X_add_one_pow
File: Mathlib/Data/Polynomial/Coeff.lean

tactic: rw [← C_1, coeff_X_add_C_pow, one_pow, one_mul]
state_before: R✝ : Type u
S : Type v
a b : R✝
n✝ m : ℕ
inst✝¹ : Semiring R✝
p q r : R✝[X]
R : Type u_1
inst✝ : Semiring R
n k : ℕ
⊢ coeff ((X + 1) ^ n) k = ↑(Nat.choose n k)
Theorem: PartENat.find_le
File: Mathlib/Data/Nat/PartENat.lean

tactic: rw [le_coe_iff]
state_before: P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h : P n
⊢ find P ≤ ↑n

tactic: refine' ⟨⟨_, h⟩, @Nat.find_min' P _ _ _ h⟩
state_before: P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h : P n
⊢ ∃ h, Part.get (find P) h ≤ n
Theorem: Function.const_le_const
File: Mathlib/Order/Basic.lean

tactic: simp [Pi.le_def]
state_before: ι : Type ?u.73033
α : Type u
β : Type v
γ : Type w
π : ι → Type ?u.73044
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Nonempty β
a b : α
⊢ const β a ≤ const β b ↔ a ≤ b
Theorem: Fin.preimage_apply_01_prod
File: Mathlib/Logic/Equiv/Fin.lean

tactic: ext f
state_before: m n : ℕ
α : Fin 2 → Type u
s : Set (α 0)
t : Set (α 1)
⊢ (fun f => (f 0, f 1)) ⁻¹' s ×ˢ t = Set.pi Set.univ (cons s (cons t finZeroElim))

tactic: have : (Fin.cons s (Fin.cons t finZeroElim) : ∀ i, Set (α i)) 1 = t := rfl
state_before: case h
m n : ℕ
α : Fin 2 → Type u
s : Set (α 0)
t : Set (α 1)
f : (i : Fin 2) → α i
⊢ f ∈ (fun f => (f 0, f 1)) ⁻¹' s ×ˢ t ↔ f ∈ Set.pi Set.univ (cons s (cons t finZeroElim))

tactic: simp [Fin.forall_fin_two, this]
state_before: case h
m n : ℕ
α : Fin 2 → Type u
s : Set (α 0)
t : Set (α 1)
f : (i : Fin 2) → α i
this : cons s (cons t finZeroElim) 1 = t
⊢ f ∈ (fun f => (f 0, f 1)) ⁻¹' s ×ˢ t ↔ f ∈ Set.pi Set.univ (cons s (cons t finZeroElim))
Theorem: Cardinal.mk_compl_eq_mk_compl_finite_lift
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: cases nonempty_fintype α
state_before: α : Type u
β : Type v
inst✝ : Finite α
s : Set α
t : Set β
h1 : lift (#α) = lift (#β)
h2 : lift (#↑s) = lift (#↑t)
⊢ lift (#↑(sᶜ)) = lift (#↑(tᶜ))

tactic: rcases lift_mk_eq.{u, v, w}.1 h1 with ⟨e⟩
state_before: case intro
α : Type u
β : Type v
inst✝ : Finite α
s : Set α
t : Set β
h1 : lift (#α) = lift (#β)
h2 : lift (#↑s) = lift (#↑t)
val✝ : Fintype α
⊢ lift (#↑(sᶜ)) = lift (#↑(tᶜ))

tactic: letI : Fintype β := Fintype.ofEquiv α e
state_before: case intro.intro
α : Type u
β : Type v
inst✝ : Finite α
s : Set α
t : Set β
h1 : lift (#α) = lift (#β)
h2 : lift (#↑s) = lift (#↑t)
val✝ : Fintype α
e : α ≃ β
⊢ lift (#↑(sᶜ)) = lift (#↑(tᶜ))

tactic: replace h1 : Fintype.card α = Fintype.card β := (Fintype.ofEquiv_card _).symm
state_before: case intro.intro
α : Type u
β : Type v
inst✝ : Finite α
s : Set α
t : Set β
h1 : lift (#α) = lift (#β)
h2 : lift (#↑s) = lift (#↑t)
val✝ : Fintype α
e : α ≃ β
this : Fintype β := Fintype.ofEquiv α e
⊢ lift (#↑(sᶜ)) = lift (#↑(tᶜ))

tactic: classical
  lift s to Finset α using s.toFinite
  lift t to Finset β using t.toFinite
  simp only [Finset.coe_sort_coe, mk_fintype, Fintype.card_coe, lift_natCast, Nat.cast_inj] at h2
  simp only [← Finset.coe_compl, Finset.coe_sort_coe, mk_coe_finset, Finset.card_compl,
    lift_natCast, Nat.cast_inj, h1, h2]
state_before: case intro.intro
α : Type u
β : Type v
inst✝ : Finite α
s : Set α
t : Set β
h2 : lift (#↑s) = lift (#↑t)
val✝ : Fintype α
e : α ≃ β
this : Fintype β := Fintype.ofEquiv α e
h1 : Fintype.card α = Fintype.card β
⊢ lift (#↑(sᶜ)) = lift (#↑(tᶜ))

tactic: lift s to Finset α using s.toFinite
state_before: case intro.intro
α : Type u
β : Type v
inst✝ : Finite α
s : Set α
t : Set β
h2 : lift (#↑s) = lift (#↑t)
val✝ : Fintype α
e : α ≃ β
this : Fintype β := Fintype.ofEquiv α e
h1 : Fintype.card α = Fintype.card β
⊢ lift (#↑(sᶜ)) = lift (#↑(tᶜ))

tactic: lift t to Finset β using t.toFinite
state_before: case intro.intro.intro
α : Type u
β : Type v
inst✝ : Finite α
t : Set β
val✝ : Fintype α
e : α ≃ β
this : Fintype β := Fintype.ofEquiv α e
h1 : Fintype.card α = Fintype.card β
s : Finset α
h2 : lift (#↑↑s) = lift (#↑t)
⊢ lift (#↑(↑sᶜ)) = lift (#↑(tᶜ))

tactic: simp only [Finset.coe_sort_coe, mk_fintype, Fintype.card_coe, lift_natCast, Nat.cast_inj] at h2
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
inst✝ : Finite α
val✝ : Fintype α
e : α ≃ β
this : Fintype β := Fintype.ofEquiv α e
h1 : Fintype.card α = Fintype.card β
s : Finset α
t : Finset β
h2 : lift (#↑↑s) = lift (#↑↑t)
⊢ lift (#↑(↑sᶜ)) = lift (#↑(↑tᶜ))

tactic: simp only [← Finset.coe_compl, Finset.coe_sort_coe, mk_coe_finset, Finset.card_compl,
  lift_natCast, Nat.cast_inj, h1, h2]
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
inst✝ : Finite α
val✝ : Fintype α
e : α ≃ β
this : Fintype β := Fintype.ofEquiv α e
h1 : Fintype.card α = Fintype.card β
s : Finset α
t : Finset β
h2 : Finset.card s = Finset.card t
⊢ lift (#↑(↑sᶜ)) = lift (#↑(↑tᶜ))
Theorem: InnerProductGeometry.norm_add_sq_eq_norm_sq_add_norm_sq_iff_angle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [norm_add_sq_eq_norm_sq_add_norm_sq_iff_real_inner_eq_zero]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
⊢ ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ ↔ angle x y = π / 2

tactic: exact inner_eq_zero_iff_angle_eq_pi_div_two x y
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
⊢ inner x y = 0 ↔ angle x y = π / 2
Theorem: Int.odd_pow
File: Mathlib/Data/Int/Parity.lean

tactic: rw [← not_iff_not, ← Int.even_iff_not_odd, not_or, ← Int.even_iff_not_odd, Int.even_pow]
state_before: m n✝ : ℤ
n : ℕ
⊢ Odd (m ^ n) ↔ Odd m ∨ n = 0
Theorem: Set.inter_nonempty_iff_exists_right
File: Mathlib/Data/Set/Basic.lean

tactic: simp_rw [inter_nonempty, and_comm]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
⊢ Set.Nonempty (s ∩ t) ↔ ∃ x, x ∈ t ∧ x ∈ s
Theorem: IsFractionRing.mk'_num_den'
File: Mathlib/RingTheory/Localization/NumDen.lean

tactic: rw [← mk'_eq_div]
state_before: R : Type ?u.14437
inst✝⁹ : CommRing R
M : Submonoid R
S : Type ?u.14643
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
P : Type ?u.14897
inst✝⁶ : CommRing P
A : Type u_2
inst✝⁵ : CommRing A
inst✝⁴ : IsDomain A
inst✝³ : UniqueFactorizationMonoid A
K : Type u_1
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
x : K
⊢ ↑(algebraMap A K) (num A x) / ↑(algebraMap A K) ↑(den A x) = x

tactic: apply mk'_num_den
state_before: R : Type ?u.14437
inst✝⁹ : CommRing R
M : Submonoid R
S : Type ?u.14643
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
P : Type ?u.14897
inst✝⁶ : CommRing P
A : Type u_2
inst✝⁵ : CommRing A
inst✝⁴ : IsDomain A
inst✝³ : UniqueFactorizationMonoid A
K : Type u_1
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
x : K
⊢ mk' K (num A x) (den A x) = x
Theorem: Dfinsupp.erase_add
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: simp [ite_zero_add]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
i : ι
f₁ f₂ : Π₀ (i : ι), β i
x✝ : ι
⊢ ↑(erase i (f₁ + f₂)) x✝ = ↑(erase i f₁ + erase i f₂) x✝
Theorem: AddMonoidAlgebra.opRingEquiv_single
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: simp
state_before: k : Type u₁
G : Type u₂
R : Type ?u.2383656
inst✝¹ : Semiring k
inst✝ : AddCommMonoid G
r : k
x : G
⊢ ↑AddMonoidAlgebra.opRingEquiv (op (single x r)) = single x (op r)
Theorem: Acc.rank_eq
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: change (Acc.intro a fun _ => h.inv).rank = _
state_before: α : Type u
r : α → α → Prop
a b : α
h : Acc r a
⊢ rank h = sup fun b => succ (rank (_ : Acc r ↑b))

tactic: rfl
state_before: α : Type u
r : α → α → Prop
a b : α
h : Acc r a
⊢ rank (_ : Acc (fun x => r x) a) = sup fun b => succ (rank (_ : Acc r ↑b))
Theorem: LucasLehmer.ω_pow_eq_one
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: rw [← pow_mul, ← Nat.pow_succ]
state_before: p' : ℕ
h : lucasLehmerResidue (p' + 2) = 0
⊢ ω ^ 2 ^ (p' + 2) = (ω ^ 2 ^ (p' + 1)) ^ 2

tactic: rw [ω_pow_eq_neg_one p' h]
state_before: p' : ℕ
h : lucasLehmerResidue (p' + 2) = 0
⊢ (ω ^ 2 ^ (p' + 1)) ^ 2 = (-1) ^ 2

tactic: simp
state_before: p' : ℕ
h : lucasLehmerResidue (p' + 2) = 0
⊢ (-1) ^ 2 = 1
Theorem: ContinuousAffineMap.coe_contLinear_eq_linear
File: Mathlib/Analysis/NormedSpace/ContinuousAffineMap.lean

tactic: ext
state_before: 𝕜 : Type ?u.13843
R : Type u_1
V : Type u_2
W : Type u_3
W₂ : Type ?u.13855
P : Type u_4
Q : Type u_5
Q₂ : Type ?u.13864
inst✝¹⁶ : NormedAddCommGroup V
inst✝¹⁵ : MetricSpace P
inst✝¹⁴ : NormedAddTorsor V P
inst✝¹³ : NormedAddCommGroup W
inst✝¹² : MetricSpace Q
inst✝¹¹ : NormedAddTorsor W Q
inst✝¹⁰ : NormedAddCommGroup W₂
inst✝⁹ : MetricSpace Q₂
inst✝⁸ : NormedAddTorsor W₂ Q₂
inst✝⁷ : NormedField R
inst✝⁶ : NormedSpace R V
inst✝⁵ : NormedSpace R W
inst✝⁴ : NormedSpace R W₂
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 V
inst✝¹ : NormedSpace 𝕜 W
inst✝ : NormedSpace 𝕜 W₂
f : P →A[R] Q
⊢ ↑(contLinear f) = f.linear

tactic: rfl
state_before: case h
𝕜 : Type ?u.13843
R : Type u_1
V : Type u_2
W : Type u_3
W₂ : Type ?u.13855
P : Type u_4
Q : Type u_5
Q₂ : Type ?u.13864
inst✝¹⁶ : NormedAddCommGroup V
inst✝¹⁵ : MetricSpace P
inst✝¹⁴ : NormedAddTorsor V P
inst✝¹³ : NormedAddCommGroup W
inst✝¹² : MetricSpace Q
inst✝¹¹ : NormedAddTorsor W Q
inst✝¹⁰ : NormedAddCommGroup W₂
inst✝⁹ : MetricSpace Q₂
inst✝⁸ : NormedAddTorsor W₂ Q₂
inst✝⁷ : NormedField R
inst✝⁶ : NormedSpace R V
inst✝⁵ : NormedSpace R W
inst✝⁴ : NormedSpace R W₂
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 V
inst✝¹ : NormedSpace 𝕜 W
inst✝ : NormedSpace 𝕜 W₂
f : P →A[R] Q
x✝ : V
⊢ ↑↑(contLinear f) x✝ = ↑f.linear x✝
Theorem: Nat.unpair_pair
File: Mathlib/Data/Nat/Pairing.lean

tactic: dsimp only [pair]
state_before: a b : ℕ
⊢ unpair (pair a b) = (a, b)

tactic: split_ifs with h
state_before: a b : ℕ
⊢ unpair (if a < b then b * b + a else a * a + a + b) = (a, b)

tactic: show unpair (b * b + a) = (a, b)
state_before: case inl
a b : ℕ
h : a < b
⊢ unpair (b * b + a) = (a, b)

tactic: have be : sqrt (b * b + a) = b := sqrt_add_eq _ (le_trans (le_of_lt h) (Nat.le_add_left _ _))
state_before: case inl
a b : ℕ
h : a < b
⊢ unpair (b * b + a) = (a, b)

tactic: simp [unpair, be, add_tsub_cancel_right, h]
state_before: case inl
a b : ℕ
h : a < b
be : sqrt (b * b + a) = b
⊢ unpair (b * b + a) = (a, b)

tactic: show unpair (a * a + a + b) = (a, b)
state_before: case inr
a b : ℕ
h : ¬a < b
⊢ unpair (a * a + a + b) = (a, b)

tactic: have ae : sqrt (a * a + (a + b)) = a := by
  rw [sqrt_add_eq]
  exact add_le_add_left (le_of_not_gt h) _
state_before: case inr
a b : ℕ
h : ¬a < b
⊢ unpair (a * a + a + b) = (a, b)

tactic: simp [unpair, ae, Nat.not_lt_zero, add_assoc]
state_before: case inr
a b : ℕ
h : ¬a < b
ae : sqrt (a * a + (a + b)) = a
⊢ unpair (a * a + a + b) = (a, b)

tactic: rw [sqrt_add_eq]
state_before: a b : ℕ
h : ¬a < b
⊢ sqrt (a * a + (a + b)) = a

tactic: exact add_le_add_left (le_of_not_gt h) _
state_before: case h
a b : ℕ
h : ¬a < b
⊢ a + b ≤ a + a
Theorem: orderOf_dvd_nat_card
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: cases' fintypeOrInfinite G with h h
state_before: G✝ : Type u
A : Type v
x✝ y : G✝
a b : A
n m : ℕ
inst✝³ : Group G✝
inst✝² : AddGroup A
inst✝¹ : Fintype G✝
G : Type u_1
inst✝ : Group G
x : G
⊢ orderOf x ∣ Nat.card G

tactic: simp only [Nat.card_eq_fintype_card, orderOf_dvd_card_univ]
state_before: case inl
G✝ : Type u
A : Type v
x✝ y : G✝
a b : A
n m : ℕ
inst✝³ : Group G✝
inst✝² : AddGroup A
inst✝¹ : Fintype G✝
G : Type u_1
inst✝ : Group G
x : G
h : Fintype G
⊢ orderOf x ∣ Nat.card G

tactic: simp only [card_eq_zero_of_infinite, dvd_zero]
state_before: case inr
G✝ : Type u
A : Type v
x✝ y : G✝
a b : A
n m : ℕ
inst✝³ : Group G✝
inst✝² : AddGroup A
inst✝¹ : Fintype G✝
G : Type u_1
inst✝ : Group G
x : G
h : Infinite G
⊢ orderOf x ∣ Nat.card G
Theorem: DihedralGroup.orderOf_r_one
File: Mathlib/GroupTheory/SpecificGroups/Dihedral.lean

tactic: rcases eq_zero_or_neZero n with (rfl | hn)
state_before: n : ℕ
⊢ orderOf (r 1) = n

tactic: rw [orderOf_eq_zero_iff']
state_before: case inl

⊢ orderOf (r 1) = 0

tactic: intro n hn
state_before: case inl

⊢ ∀ (n : ℕ), 0 < n → r 1 ^ n ≠ 1

tactic: rw [r_one_pow, one_def]
state_before: case inl
n : ℕ
hn : 0 < n
⊢ r 1 ^ n ≠ 1

tactic: apply mt r.inj
state_before: case inl
n : ℕ
hn : 0 < n
⊢ r ↑n ≠ r 0

tactic: simpa using hn.ne'
state_before: case inl
n : ℕ
hn : 0 < n
⊢ ¬↑n = 0

tactic: apply (Nat.le_of_dvd (NeZero.pos n) <|
  orderOf_dvd_of_pow_eq_one <| @r_one_pow_n n).lt_or_eq.resolve_left
state_before: case inr
n : ℕ
hn : NeZero n
⊢ orderOf (r 1) = n

tactic: intro h
state_before: case inr
n : ℕ
hn : NeZero n
⊢ ¬orderOf (r 1) < n

tactic: have h1 : (r 1 : DihedralGroup n) ^ orderOf (r 1) = 1 := pow_orderOf_eq_one _
state_before: case inr
n : ℕ
hn : NeZero n
h : orderOf (r 1) < n
⊢ False

tactic: rw [r_one_pow] at h1
state_before: case inr
n : ℕ
hn : NeZero n
h : orderOf (r 1) < n
h1 : r 1 ^ orderOf (r 1) = 1
⊢ False

tactic: injection h1 with h2
state_before: case inr
n : ℕ
hn : NeZero n
h : orderOf (r 1) < n
h1 : r ↑(orderOf (r 1)) = 1
⊢ False

tactic: rw [← ZMod.val_eq_zero, ZMod.val_nat_cast, Nat.mod_eq_of_lt h] at h2
state_before: case inr
n : ℕ
hn : NeZero n
h : orderOf (r 1) < n
h2 : ↑(orderOf (r 1)) = 0
⊢ False

tactic: exact absurd h2.symm (orderOf_pos _).ne
state_before: case inr
n : ℕ
hn : NeZero n
h : orderOf (r 1) < n
h2 : orderOf (r 1) = 0
⊢ False
Theorem: Finset.disjSups_inter_subset_right
File: Mathlib/Data/Finset/Sups.lean

tactic: simpa only [disjSups, product_inter, filter_inter_distrib] using image_inter_subset _ _ _
state_before: α : Type u_1
inst✝³ : DecidableEq α
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
inst✝ : DecidableRel Disjoint
s s₁ s₂ t t₁ t₂ u : Finset α
a b c : α
⊢ s ○ (t₁ ∩ t₂) ⊆ s ○ t₁ ∩ s ○ t₂
Theorem: List.Nat.antidiagonal_succ_succ'
File: Mathlib/Data/List/NatAntidiagonal.lean

tactic: rw [antidiagonal_succ']
state_before: n : ℕ
⊢ antidiagonal (n + 2) = (0, n + 2) :: map (Prod.map succ succ) (antidiagonal n) ++ [(n + 2, 0)]

tactic: simp
state_before: n : ℕ
⊢ map (Prod.map id succ) (antidiagonal (n + 1)) ++ [(n + 1 + 1, 0)] =
    (0, n + 2) :: map (Prod.map succ succ) (antidiagonal n) ++ [(n + 2, 0)]

tactic: ext
state_before: n : ℕ
⊢ map (Prod.map id succ ∘ Prod.map succ id) (antidiagonal n) = map (Prod.map succ succ) (antidiagonal n)

tactic: simp
state_before: case a.a
n n✝ : ℕ
a✝ : ℕ × ℕ
⊢ a✝ ∈ get? (map (Prod.map id succ ∘ Prod.map succ id) (antidiagonal n)) n✝ ↔
    a✝ ∈ get? (map (Prod.map succ succ) (antidiagonal n)) n✝
Theorem: Seminorm.balanced_ball_zero
File: Mathlib/Analysis/Seminorm.lean

tactic: rintro a ha x ⟨y, hy, hx⟩
state_before: R : Type ?u.1051890
R' : Type ?u.1051893
𝕜 : Type u_1
𝕜₂ : Type ?u.1051899
𝕜₃ : Type ?u.1051902
𝕝 : Type ?u.1051905
E : Type u_2
E₂ : Type ?u.1051911
E₃ : Type ?u.1051914
F : Type ?u.1051917
G : Type ?u.1051920
ι : Type ?u.1051923
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p : Seminorm 𝕜 E
r : ℝ
⊢ Balanced 𝕜 (ball p 0 r)

tactic: rw [mem_ball_zero, ← hx, map_smul_eq_mul]
state_before: case intro.intro
R : Type ?u.1051890
R' : Type ?u.1051893
𝕜 : Type u_1
𝕜₂ : Type ?u.1051899
𝕜₃ : Type ?u.1051902
𝕝 : Type ?u.1051905
E : Type u_2
E₂ : Type ?u.1051911
E₃ : Type ?u.1051914
F : Type ?u.1051917
G : Type ?u.1051920
ι : Type ?u.1051923
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p : Seminorm 𝕜 E
r : ℝ
a : 𝕜
ha : ‖a‖ ≤ 1
x y : E
hy : y ∈ ball p 0 r
hx : (fun x => a • x) y = x
⊢ x ∈ ball p 0 r

tactic: calc
  _ ≤ p y := mul_le_of_le_one_left (map_nonneg p _) ha
  _ < r := by rwa [mem_ball_zero] at hy
state_before: case intro.intro
R : Type ?u.1051890
R' : Type ?u.1051893
𝕜 : Type u_1
𝕜₂ : Type ?u.1051899
𝕜₃ : Type ?u.1051902
𝕝 : Type ?u.1051905
E : Type u_2
E₂ : Type ?u.1051911
E₃ : Type ?u.1051914
F : Type ?u.1051917
G : Type ?u.1051920
ι : Type ?u.1051923
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p : Seminorm 𝕜 E
r : ℝ
a : 𝕜
ha : ‖a‖ ≤ 1
x y : E
hy : y ∈ ball p 0 r
hx : (fun x => a • x) y = x
⊢ ‖a‖ * ↑p y < r

tactic: rwa [mem_ball_zero] at hy
state_before: R : Type ?u.1051890
R' : Type ?u.1051893
𝕜 : Type u_1
𝕜₂ : Type ?u.1051899
𝕜₃ : Type ?u.1051902
𝕝 : Type ?u.1051905
E : Type u_2
E₂ : Type ?u.1051911
E₃ : Type ?u.1051914
F : Type ?u.1051917
G : Type ?u.1051920
ι : Type ?u.1051923
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p : Seminorm 𝕜 E
r : ℝ
a : 𝕜
ha : ‖a‖ ≤ 1
x y : E
hy : y ∈ ball p 0 r
hx : (fun x => a • x) y = x
⊢ ↑p y < r
Theorem: gcd_mul_left'
File: Mathlib/Algebra/GCDMonoid/Basic.lean

tactic: obtain rfl | ha := eq_or_ne a 0
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b c : α
⊢ Associated (gcd (a * b) (a * c)) (a * gcd b c)

tactic: obtain ⟨d, eq⟩ := dvd_gcd (dvd_mul_right a b) (dvd_mul_right a c)
state_before: case inr
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b c : α
ha : a ≠ 0
⊢ Associated (gcd (a * b) (a * c)) (a * gcd b c)

tactic: apply associated_of_dvd_dvd
state_before: case inr.intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b c : α
ha : a ≠ 0
d : α
eq : gcd (a * b) (a * c) = a * d
⊢ Associated (gcd (a * b) (a * c)) (a * gcd b c)

tactic: simp only [zero_mul, gcd_zero_left']
state_before: case inl
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
b c : α
⊢ Associated (gcd (0 * b) (0 * c)) (0 * gcd b c)

tactic: rw [eq]
state_before: case inr.intro.hab
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b c : α
ha : a ≠ 0
d : α
eq : gcd (a * b) (a * c) = a * d
⊢ gcd (a * b) (a * c) ∣ a * gcd b c

tactic: apply mul_dvd_mul_left
state_before: case inr.intro.hab
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b c : α
ha : a ≠ 0
d : α
eq : gcd (a * b) (a * c) = a * d
⊢ a * d ∣ a * gcd b c

tactic: exact
  dvd_gcd ((mul_dvd_mul_iff_left ha).1 <| eq ▸ gcd_dvd_left _ _)
    ((mul_dvd_mul_iff_left ha).1 <| eq ▸ gcd_dvd_right _ _)
state_before: case inr.intro.hab.h
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b c : α
ha : a ≠ 0
d : α
eq : gcd (a * b) (a * c) = a * d
⊢ d ∣ gcd b c

tactic: exact dvd_gcd (mul_dvd_mul_left a <| gcd_dvd_left _ _) (mul_dvd_mul_left a <| gcd_dvd_right _ _)
state_before: case inr.intro.hba
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b c : α
ha : a ≠ 0
d : α
eq : gcd (a * b) (a * c) = a * d
⊢ a * gcd b c ∣ gcd (a * b) (a * c)
Theorem: LinearMap.ker_le_range_iff
File: Mathlib/LinearAlgebra/Quotient.lean

tactic: rw [← range_le_ker_iff, Submodule.ker_mkQ, Submodule.range_subtype]
state_before: R : Type u_1
M : Type u_3
R₂ : Type u_2
M₂ : Type u_4
R₃ : Type u_5
M₃ : Type u_6
inst✝¹⁰ : Ring R
inst✝⁹ : Ring R₂
inst✝⁸ : Ring R₃
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommGroup M₂
inst✝⁵ : AddCommMonoid M₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
g : M₂ →ₛₗ[τ₂₃] M₃
⊢ ker g ≤ range f ↔ comp (mkQ (range f)) (Submodule.subtype (ker g)) = 0
Theorem: LinearMap.toMatrix_comp
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: simp_rw [LinearMap.toMatrix, LinearEquiv.trans_apply, LinearEquiv.arrowCongr_comp _ v₂.equivFun,
  LinearMap.toMatrix'_comp]
state_before: R : Type u_3
inst✝¹¹ : CommSemiring R
l : Type u_1
m : Type u_2
n : Type u_7
inst✝¹⁰ : Fintype n
inst✝⁹ : Fintype m
inst✝⁸ : DecidableEq n
M₁ : Type u_6
M₂ : Type u_4
inst✝⁷ : AddCommMonoid M₁
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : Module R M₁
inst✝⁴ : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type u_5
inst✝³ : AddCommMonoid M₃
inst✝² : Module R M₃
v₃ : Basis l R M₃
inst✝¹ : Fintype l
inst✝ : DecidableEq m
f : M₂ →ₗ[R] M₃
g : M₁ →ₗ[R] M₂
⊢ ↑(toMatrix v₁ v₃) (comp f g) = ↑(toMatrix v₂ v₃) f ⬝ ↑(toMatrix v₁ v₂) g